There are many ways of forcing a type-checker to accept this.

1. Use assert:

   from typing import Union
   
   def do_something(var: Union[T, None]):
       assert var is not None
       var.foo()
   

2. Raise some other exception:

   from typing import Union
   
   def do_something(var: Union[T, None]):
       if var is None:
           raise RuntimeError("NO")
       var.foo()
   

3. Use an if statement:

   from typing import Union
   
   def do_something(var: Union[T, None]):
       if var is not None:
           var.foo()
   

4. Use typing.cast, a function that does nothing at runtime but forces a type-checker to accept that a variable is of a certain type:

   from typing import Union, cast
   
   def do_something(var: Union[T, None]):
       var = cast(T, var)
       var.foo()
   

5. Switch off the type-checker for that line:

   from typing import Union
   
   def do_something(var: Union[T, None]):
       var.foo()  # type: ignore
   

Note also that, while it makes no difference to how your type annotation is interpreted by a type-checker (the two are semantically identical), you can also write typing.Union[T, None] as typing.Optional[T], which is arguably slightly nicer syntax. In Python >=3.10 (or earlier if you have from __future__ import annotations at the top of your code), you can even write Union types with the | operator, i.e. T | None.

Please don’t use blanket # type: ignore. Instead be specific on what linting error you want to ignore:

myOptionalVar.foo()         # pyright: ignore[reportOptionalMemberAccess]

Above works in VSCode default linter Pylance which uses Pyright.

from /a/71523301/54745

6. In a class, use a private member and a property:

   class something:
       def __init__(self):
           self._var = None
   
       @property
       def var(self) -> T:
           assert self._var is not None
           return self._var
   
       def do_something(self)
           self.var.foo()