Nested Object Attributes Won't Autocomplete

[mattdonders]

I have a nested object structure for managing Teams within a Game object and when trying to access attributes of that nested object, the autocomplete doesn't recommend object attributes correctly / at all..

At a high level - these are the two classes in question (code snippets).

class Game:
    def __init__(self, ...):

        self.game_id = game_id
        self.game_type = game_type
        self.date_time = date_time
        self.game_state = game_state
        self.venue = venue
        self.live_feed_endpoint = live_feed
        self.home_team = home
        self.away_team = away
        self.season = season

        # Not passed in at object creation time
        if preferred == "home":
            self.preferred_team = home
            self.other_team = away
        else:
            self.preferred_team = away
            self.other_team = home

class Team(object):
    """Holds attributes related to a team - usually two created per game."""

    def __init__(
        self, team_id, team_name, short_name, tri_code, home_away, tv_channel, games, record, season
    ):
        self.team_id = team_id
        self.team_name = team_name
        self.short_name = short_name
        self.tri_code = tri_code
        self.home_away = home_away
        self.tv_channel = tv_channel
        self.games = games
        self.record = record
        self.season = season

So as you can see each Game object holds two team objects two times - each in home / away and then in preferred / other.

Accessing the Game object in another class or function works just fine and I get all my autocompletes, but once I try to access the Team object held within the Game object I no longer get any autocomplete (screenshots below).

Any help would be greatly appreciated. If this is not a PLS issue I can raise it in the main vscode repository, but when using Jedi, Visual Studio doesn't even give me object attributes of the Game object so the behavior is worse.

Thanks in advance!

[jakebailey]

No, this would be a PLS issue (vscode would point you back to us).

This is probably due to the if statements in the __init__ method. If you don't conditionally set them in the initializer, does the autocompletion show up?

[mattdonders]

@jakebailey I just tried to see if I could use the ones that are not in the if / else portion of the __init__ method -- tried accessing game.home_team and game.away_team and still get the same issue (screenshot included below).

To be perfectly honest I am not sure how often people nest objects like this or if this is just overcomplicating my code, but figured I couldn't be the only way to even store a nested object for easier tracking.

Thanks so much!

[jakebailey]

Can you hover over the game in self.game and show a screenshot?

[mattdonders]

Could it possibly have anything to do with me importing the Game object at the top of my code? I just realized that I do that for something else and I also type-specify in my __init__ function.

from hockeygamebot.models.game import Game

Should I import my Team class as well? I wonder if that will help?

[jakebailey]

You shouldn't need to do an import if something is in the same file, no.

If you have a code sample where this breaks, I'd appreciate it if you could push it somewhere (a repo or gist).

[mattdonders]

So this code, the Game class & the Team class are all in separate files. I wonder if it's just coincidence that the Game object attributes resolve because I import that file into the class I am working on.

I wasn't sure if I needed the import for the autocomplete to work because I am just passing the object and it's attributes into this class but not using the class directly.

Is there any other internal methods I can define in the Game or Team class to help this autocomplete work any better?

The code for this project is here, but I can provide a sample code snippet that helps to generate some of these objects if that helps to put together a reproducible project.

https://github.com/mattdonders/nhl-twitter-bot/tree/refactor-v2/hockeygamebot/models

[jakebailey]

Without knowing that a specific parameter is going to be a specific type, we can't provide completion for it in that sense, no. If you know that some member is going to be some type, you should use Python 3 type hints, or perhaps some PEP 484-esque comment.

Note that in Python, splitting classes all into their own files is very unusual. I'd say that what you have in that repo is un-idiomatic, and you're probably having issues due to that.

You'd probably be better off merging all of those inter-related files into a single module named "models", in which everything relates to everything else. Cutting files by types leads to very "Java-esque" uses later on where you need to explicitly import every single file that has a type you want, and you end up either stuttering (game.Game) or pulling everything into scope (from game import Game), at which point you could be doing from models import Game, Team, etc.

Anyway, from what I can tell, you have an example where one file is:

class Foo:
    def __init__(self, bar):
        self.bar = bar

And another file:

class Bar:
    def __init__(self, x):
        self.x = x

And you'd like completion in Foo on bar to be that from Bar, but that wouldn't be possible when editing Foo unless there's some hint to say that bar is Bar. This is because we look at a module on its own, and wouldn't provide information about uses of it. For example, a user may pass in something completely different for bar.

[mattdonders]

@jakebailey thanks for the detailed response - I really appreciate you taking the time to do that.

So I totally understand what you've said but I had a Pythonic question then. If I condense all of these classes & related functions into a single models.py file does it make sense to have it in models/models.py directory structure for organizational purposes? And if so would I import it like from hockeygamebot.models import models whenever I need to use a model and access it via the models.Game() namespace?

And if I do condense this all into a single models.py file I should have no issues with autocomplete anywhere else in the code because all classes no about each other?

[jakebailey]

Here are two ways to make a module hockeygamebot.models:

• Make a file models.py in the hockeygamebot directory and put code there.
• Make a file __init__.py in the hockeygamebot/models directory and put code there.

The first would be my choice.

As for autocompete, when working in that file, you'd have access to all of the types in that file (as they're declared there), but it wouldn't change the fact that the __init__ signature doesn't provide any hint that game is supposed to be an instance of Game.

[mattdonders]

This is phenomenal - thanks so much for the insight into this (and a better way to organize my code)!

One more question (if you don't mind) - if in the __init__ function of my Game class I type-hint the Team variables being passed into that class, would it help the autocomplete have a better understanding even when I merge all the classes together?

I'm going to do all of this stuff tonight and report back to this issue to make sure this resolves all of my underlying autocomplete things I was seeing / not seeing.

[jakebailey]

Type hints will likely help, yes, and saying def __init__(self, game: Game) may be enough to get what you want.

[mattdonders]

Just wanted to provide an update to this before I start merging code around as you recommended (and given more research it definitely makes more sense).

So I type-hinted the Team objects in my Game class -

class Game:
    def __init__(self, game_id, game_type, date_time, game_state, venue, home: Team, away: Team, preferred, live_feed, season):

        self.game_id = game_id
        self.game_type = game_type
        self.date_time = date_time
        self.game_state = game_state
        self.venue = venue
        self.live_feed_endpoint = live_feed
        self.home_team = home
        self.away_team = away
        self.season = season

        # Not passed in at object creation time
        if preferred == "home":
            self.preferred_team = home
            self.other_team = away
        else:
            self.preferred_team = away
            self.other_team = home

Now when doing so, the autocomplete of those nested objects works just as the parent object does (& even works for the if / else reassigned objects).

So given this information I am going to close this issue since I don't think this is an issue at all with the Python Language Server, but just understanding how my code should be structured and how type-hinting can help any autocomplete system understand the attributes of an object.

@jakebailey thanks again for all your help in here. Going to take some time tonight to move some code around and create a single models file so (to your point) my code doesn't start creeping into a Java-like syntax.