asserts (and a question about polymorphism)

[colinRawlings]

For our (boost::python) wrapped C++ we have many cases like:

class DataObject():
    ...

class Grid(DataObject):
    ...
    def GetNumberOfPoints(self)->int:
        ...
    
class Filter:
    ...
    def GetOutput(self)->DataObject:

Which when used in scripts leads to

grid = filter.GetOutput()
assert isinstance(grid, Grid)
print(grid.GetNumberOfPoints())  # without the assert this yields a type error: Cannot access member "GetNumberOfPoints" for type "DataObject"

My questions are two fold (and I think unrelated).

• Given the possibility of using the -O argument when invoking python is there an option for asking pyright to only accept:

if not isinstance(grid, Grid):
    raise RuntimeError("Not a grid")

• Is there a shorthand for annotating your expectation that this will be a certain derived class?

[erictraut]

I don't have enough information about your class hierarchy or how these classes are used, but based on the code you posted, it seems like the Filter class should be generic.

_DO = TypeVar("_DO", bound=DataObject)
class Filter(Generic[_DO]):
    ...
    def GetOutput(self)->_DO: ...

This would eliminate the need for asserts or other runtime checks to verify that it's an expected subclass.

You are correct that Python can be run using the -O argument which means that the runtime behavior could change if the assertion is violated. Instead of receiving an AssertionError, you will likely see some other crash or undesirable behavior later in the code.

An assert statement should not be used for control flow; it should be used to document an assumption that you are making in your code. If your intent is to affect the code flow, you should use an explicit isinstance call or a user-defined type guard.

So yes, it's possible for assert to be used improperly, but that's true of any statement in a programming language. In practice, I don't think assert is misused in most Python code. If this were a common source of bugs, then we could look for ways for pyright to help prevent these bugs, but my sense is that it's not a common problem.

[colinRawlings]

Thanks for the hint about Generic. I haven't fully digested the PEP but it may well be what I need to handle derived classes (like Filter) whose public methods (like GetOutput) are defined in a base class (and hence return the base data type).

Your statement about asserts documenting assumptions and hence being a valid basis for the type checker's decision making process makes absolute sense.

Thanks a lot for your help and thanks for a very valuable tool.