How to actually capture PanicException?

[markkimsal]

So, I've read a lot of issues about PanicException being sub of BaseException and what not. Some replies say "Just catch (Exception, PanicException)". But how do you actually do that?

    try:
        complicated_python_and_rust_library(strIn)
    except (Exception, PanicException) as e:
        with push_scope() as scope:
            scope.add_attachment(
                bytes=strIn.encode(),
            )
            capture_exception(e)
            raise e

PanicException is not a thing in python. I can't import it from my extension either.

I've seen just catch BaseException, and re-throw it if it's not Panic, but how do you do that and also catch like... other logic Exceptoins

except BaseException as e:
  if not "PanicException" in str(type(e)):
    raise

But, all regular exceptions will not be Panic...

      except (Exception, BaseException) as e:
        if not "PanicException" in str(type(e)):
            raise e
         with push_scope() as scope:
            scope.add_attachment(
                bytes=strIn.encode(),
            )
            capture_exception(e)
            raise e

I'm just looking for one example of how to work with Panic/Base exception in its current form. I'm trying to log asserts and unwrap Nones. Thanks

Edit:
I guess I can just log all base exceptions and see what happens? I've read some stuff about BaseException and how it could hang your program if you misuse it, so I don't want to hang my program

[LilyFirefly]

Why do you want to handle PanicException specifically? It's designed to bubble up and end the program, similar to KeyboardInterrupt and SystemExit.

[markkimsal]

I'm not sure what else is a BaseException or how else they could happen. I guess that's the root of the issue. What problems could arise handling all BaseExceptions instead of the narrower PanicException?

[LilyFirefly]

Here's all the BaseException subclasses in Python itself: https://docs.python.org/3/library/exceptions.html#exception-hierarchy

The main one I didn't mention is GeneratorExit, but that should never bubble up out of generators or coroutines.

[markkimsal]

I think something like this will allow me to capture my library exceptions from python, and None::unrwrap() from the Rust code w/o accidentally dealing with new exceptions that I really don't want to mishandle

    try:
        complicated_python_and_rust_library(strIn)
    except (Exception, BaseException) as e:
        if str(type(e)) in ["BaseExceptionGroup", "GeneratorExit", "KeyboardInterrupt", "SystemExit"]:
            raise e
        with push_scope() as scope:
            scope.add_attachment(
                bytes=strIn.encode(),
            )
            capture_exception(e)
            raise e

[LilyFirefly]

I think you can write it like this:

    try:
        complicated_python_and_rust_library(strIn)
    except (GeneratorExit, KeyboardInterrupt, SystemExit):
        raise
    except BaseException as e:
        with push_scope() as scope:
            scope.add_attachment(
                bytes=strIn.encode(),
            )
            capture_exception(e)
            raise e

I didn't include handling for BaseExceptionGroup because I haven't needed to work with exception groups at all yet, so don't really know what to suggest there. But https://docs.python.org/3/tutorial/errors.html#raising-and-handling-multiple-unrelated-exceptions is probably a good resource.

[markkimsal]

Yeah, this is nice. I thought about this yesterday, but I thought raiseing would push it to the next except block. But I just tested it and it does not push to the next except block.

Only caveat is taking both Exception and BaseException

    try:
        complicated_python_and_rust_library(strIn)
    except (GeneratorExit, KeyboardInterrupt, SystemExit):
        raise
    except (Exception, BaseException) as e:
        """ at this point, BaseException e should be any pyo3 PanicException
            and Exception e is any library Python exception
        """
        with push_scope() as scope:
            scope.add_attachment(
                bytes=strIn.encode(),
            )
            capture_exception(e)
            raise e

[LilyFirefly]

Exception is a subclass of BaseException too, so specifying both is redundant.