Method override in subclass is not detected, is this by design?

[Hugovdberg]

Given the following code:

class A:
    def foo(self):
        self.bar()

    def bar(self):
        raise Exception()

class B(A):
    def bar(self):
        print("baz")


b = B()
b.foo()
print("finished")

I get an error that the last line is unreachable (not quite sure if it's Pyright or Pylance generating this error in VS code). I figure this is because the A.bar unconditionally raises an exception, although it is overridden in class B to do something useful. I'm using some library code which has this kind of construct in its class hierarchy, which causes half my code to be "unreachable", although it works fine in practice. Is this a bug in the static analysis of the code or is this by design?

I could of course ask them to make it an ABC/abstractmethod or implement B.foo(self): super().foo(), but that will take some time. As a workaround I could either cast the b.foo to a callable so the static analysis doesn't find the exception, or wrap it in a try: except: pass block, but neither is particularly beautiful on my side.

[erictraut]

Yes, this is expected behavior. The inferred return type for A.bar is NoReturn.

You have the following options to work around this:

1. Make it an abstractmethod
2. Raise a NotImplementedError rather than Exception; this is the common (and recommended) pattern in most Python code, so pyright special-cases it
3. Add an explicit None return type annotation to A.bar so inference doesn't need to be used

[Hugovdberg]

thanks for the reply, I was already thinking that this was some poor/unpythonic coding by the maintainers of that library, therefore I didn't want to raise it as a bug. I'll raise this error over there then ;-)