Intellisense for returned python object's methods

Question

I am new to Python and I love this language much. But I encountered one annoying issue recently when working with PyDev in eclipse.

Some method returned an instance of some class. But I cannot get intellisense for the instance's methods.

For example:

import openpyxl
from openpyxl.reader.excel import load_workbook
from openpyxl.worksheet import Worksheet


xlsFile='hello.xlsx'
wbook = load_workbook(xlsFile)

wsheet1=wbook.get_sheet_by_name('mysheet')
wsheet1.cell('A9').hyperlink=r'\\sharefolder'

wsheet2=Worksheet()
wsheet2.cell('A1').hyperlink=r'\\sharefolder'

In this code, I can get the prompt for method cell() with wsheet2, but not with wsheet1. Though they are both of Worksheet type which I have already imported. It seems python or PyDev cannot properly detect the type of the returned object.

Is this a language limitation? Or is there something I did wrong? For now, I have to dig into the source code and see what the real type of the return value is. And then check the methods defined in that type. It's very tedious.

I wrote a small test to repro this issue. Strange, the intellisense seems working.

Answer 1

It's a consequence of the fact that Python is dynamically typed.

In a statically-typed language such as C#, methods are annotated with their type signatures. (Aside: in some systems types can be inferred by the type checker.) The compiler knows the return type of the function, and the types the arguments are meant to have, without running your code, because you wrote the types down! This enables your tooling to not only check the types of your programs, but also to build up metadata about the methods in your program and their types; Intellisense works by querying this metadata harvested from the text of your program.

---

Python has no static type system built in to the language. This makes it much harder for tooling to give you hints without running the code. For example, what is the return type of this function?

def spam(eggs):
    if eggs:
        return "ham"
    return 42

Sometimes spam returns a string; sometimes it returns an integer. What methods should Intellisense display on the return value of a call to spam?

What are the available attributes on this class?

class Spam:
    def __getattr__(self, name):
        if len(name) > 5:
            return "foo"
        return super().__getattr__(name)

Spam sometimes dynamically generates attributes: what should Intellisense display for an instance of Spam?

In these cases there is no correct answer. You might be able to volunteer some guesses (for example, you could show a list containing both str and int's methods on the return value of spam), but you can't give suggestions that will be right all the time.

---

So Intellisense tooling for Python is reduced to best-guesses. In the example you give, your IDE doesn't know enough about the return type of get_sheet_by_name to give you information about wsheet1. However, it does know the type of wsheet2 because you just instantiated it to a Worksheet. In your second example, Intellisense is simply making a (correct) guess about the return type of f1 by inspecting its source code.

Incidentally, auto-completion in an interactive shell like IPython is more reliable. This is because IPython actually runs the code you type. It can tell what the runtime type of an object is because the analysis is happening at runtime.

Answer 2

You can use an assert to tell intellisense what class you want it to be. Of course now it will thow an error if it isn't, but that's a good thing.

assert isinstance(my_variable, class_i_want_it_to_be)

This will give you the auto-complete and ctrl-click to jump to the function that you have been looking for. (At least this is how it works now in 2022, some other answers are 5 years old).

Here is a quick example.

#!/usr/bin/python3

class FooMaker():
    def make_foo():
        return "foo"

#this makes a list of constants
list1 = [FooMaker(),FooMaker()]

#Even if the result is the same. These are not constants
list2 = []
for i in range(2):
    list2.append(FooMaker)


#intellisense knows this is a FooMaker
m1 = list1[0]

#now intellisense isn't sure what this object is
m2 = list2[0]

# Make_foo is highlighted for m1 and not for m2
m1.make_foo()
m2.make_foo()

# now make_foo is highlighted for M2
assert isinstance(m2, FooMaker)
m2.make_foo()

The color difference is subtile in my vs code. But here is a screen shot anyway.

tldr: So many online answers just say "no" that it took me a while to say: "this is ridiculous, I don't have to deal with this in C, there must be a better way".

Yes, python is dynamically typed, but that doesn't mean that intellisence has to be necessarily banned from suggesting "you probably want this". It also doesn't mean, you have to "just deal with it" because you chose python.

Furthermore, throwing down a lot of assert functions is good practice and will shorten your development time when things start to get complicated. You might be about to pass a variable a long way down a list of functions before you get a type error. Then you have to dig a long way back up to find it. Just say what it is when you decide what it is and that's where it will throw the error when something goes wrong.

It's also much easier to show other developers what you are trying to do. I even see asserts this in C libraries, and always wondered why they bothered in a strongly typed language. But, now it makes a lot more sense. I would also speculate there is little performance hit to adding an assert (complier stuff, blah blah, I'll leave that for the comments).

Answer 3

Well, technically in Python a method may return anything and the result of an operation is defined only when the operation is completed.

Consider this simple function:

def f(a):
    if a == 1:
        return 1 # returns int
    elif a == 2:
        return "2" # returns string
    else:
        return object() # returns an `object` instance

The function is pretty valid for Python and its result is strictly defined but only at the end of the function execution. Indeed:

>>> type(f(1))
<type 'int'>
>>> type(f(2))
<type 'str'>
>>> type(f(3))
<type 'object'>

Certainly this flexibility is something not needed all the time and most methods return something predictable apriori. An intelligent IDE could analyze the code (and some other hints like docstrings which may specify arguments and return types) but this always would be a guess with a certain level of confidence. Also there's PEP0484 which introduces type hints on the language level, but it's optional, relatively new and all legacy code definitely doesn't use it.

If PyDev doesn't work for a particular case, well, it's a pity, but it's something you should accept if you choose such a dynamic language like Python. Maybe it's worth to try a different, more intelligent IDE or have a console with an interactive Python prompt opened next to your IDE to test your code on the fly. I would suggest to use a sophisticated python shell like bpython