How to make guarantees on type of field depending on where it's accessed?

[ndido98]

Hey everyone, I have the following piece of code:

from typing import Optional

class A:
    field: Optional[int]
    children: list["B"]

    def __init__(self):
        self.children = populate()  # Do stuff to populate the list
        for child in self.children:
            child.parent = self

    def do_stuff(self):
        # self.field can be None
        for child in self.children:
            child.field_could_be_optional()
        self.field = 1
        # self.field cannot be None
        for child in self.children:
            # placing assert self.field is not None here doesn't work
            child.field_is_not_optional()

class B:
    parent: A

    def field_could_be_optional(self) -> None:
        print(self.parent.field)  # can be None (statically known)

    def field_is_not_optional(self) -> None:
        # This is written by users and it would be ugly if they had to manually write the assertion
        print(self.parent.field)  # can be None but it's never None (cannot determine statically)

Is there a way to statically say that in the field_is_not_optional method self.parent.field will never be None?

[jeremyn]

I'm not completely sure what you're trying to do, but I have two general ideas to satisfy the type checker:

1. Use a conditional like:

# approach 1
if field is not None:
    print(field)

or

# approach 2
if field is None:
    raise Exception
print(field)

In either case the checker should know that field in the print statement is not None.

2. Pass the argument to field_is_not_optional explicitly as not None:

def field_is_not_optional(self, field: int) -> None:
    print(field)

This is a better approach anyway if field_is_not_optional is some kind of plugin, the users shouldn't need to know about stuff on self, let alone self.parent.