Can python `except` match against all errors in the chain?

I have a python application which constructs a long error chain with multiple raise from clauses. I'm interested defining a specific except block to catch one of the values that may occur deep within the chain. It appears that python except only checks against the first error in the chain. Is there a standard way to traverse the chain similar to errors.is in go?

Example:

class CustomException1(Exception):
  pass

class CustomException2(Exception):
  pass

class CustomException3(Exception):
  pass

def func_1():
    try:
        raise Exception("test failure")
    except Exception:
        raise CustomException1()


def func_2():
    try:
        func_1()
    except Exception as e:
        raise CustomException2() from e


def func_3():
    try:
        func_2()
    except Exception as e:
        raise CustomException3() from e


def func_4():
    try:
        func_3()
    except CustomException1:
        print("do something specific for CustomException1")
        pass
    except Exception:
        print("general exception handler")
        pass

func_4()

I ran the above code and saw the output "general exception handler". I'd like the exception to be matched by CustomException1 clause. Is there a standard method for traversing the chain?

Starting in Python 3.11, you can use exception groups to package multiple exceptions into a single package with arbitrary structure. Here, we're still preserving the linear structure implied by the call stack, but we don't need to explicitly traverse that chain to find an exception of type CustomeException1. (Though you can: except* is syntactic sugar for manipulating a caught ExceptionGroup using its API, including the subgroup, split, and derive methods.)

class CustomException1(Exception): pass    
class CustomException2(Exception): pass    
class CustomException3(Exception): pass


def func_1():
    raise CustomException1()


def func_2():
    try:
        func_1()
    except Exception as e:
        raise ExceptionGroup("from func_2", [CustomException2(), e])


def func_3():
    try:
        func_2()
    except ExceptionGroup as eg:
        raise ExceptionGroup("from func3", [CustomException3(), eg])


def func_4():
    try:
        func_3()
    except* CustomException1:
        print("do something specific for CustomException1")
    except* Exception:
        print("general exception handler")

func_4()

When you run the script, you'll see the following output:

do something specific for CustomException1
general exception handler

Note that the except* clause extracts CustomException1 from wherever in the hierarchy it may be found; the catcher need not parse the exception group manually (though it is possible using the split method, which is what except* uses in its implementation.) Also note that unlike except, except* can continue matching exceptions after each handler has executed.