Maybe it would be nice to have a test case with a longer cycle? As in

    def test_no_hang_on_context_chain_cycle2(self):
        class A(Exception):
            pass
        class B(Exception):
            pass
        class C(Exception):
            pass
        class D(Exception):
            pass
        class E(Exception):
            pass
        
        # Context cycle:
        #             +-----------+
        #             V           |
        # E --> D --> C --> B --> A
        with self.assertRaises(E):
            try:
                raise A()
            except A as _a:
                a = _a
                try:
                    raise B()
                except B as _b:
                    b = _b
                    try:
                        raise C()
                    except C as _c:
                        c = _c
                        a.__context__ = c
                        try:
                            raise D()
                        except D as _d:
                            d = _d
                            e = E()
                            raise e

        # Finish without breaking the cycle
        self.assertIs(e.__context__, d)
        self.assertIs(d.__context__, c)
        self.assertIs(c.__context__, b)
        self.assertIs(b.__context__, a)
        self.assertIs(a.__context__, c)

Also, would it be good to check that the traceback doesn't get stuck in a loop when printing? I tried it, and it terminates as you'd hope, but it's unclear to me why that's the case.

The traceback printing code does its own cycle detection. I'll extend the test, thanks.

If you do add a longer test, I would keep the short one there as it helps to have a minimal example.

I thought of another case that might be worth testing. What about e.g. A -> B -> C and then raising C while A is active (basically the "Avoid creating new reference cycles" part of your code comment)? I believe that's an example of the kind of case that comment is referencing (or if not, maybe you could add one).

I thought of another case that might be worth testing. What about e.g. A -> B -> C and then raising C while A is active (basically the "Avoid creating new reference cycles" part of your code comment)? I believe that's an example of the kind of case that comment is referencing (or if not, maybe you could add one).

You're right. This test should have been there already because this is old behaviour, but it doesn't seem to be there. I've added it.

Thank you @cjerdonek.

@pablogsal , @ambv - let's figure out how far back to backport this. According to https://bugs.python.org/issue25782#msg399281 it seems like 3.9?

Thanks @iritkatriel for the PR, and @ambv for merging it 🌮🎉.. I'm working now to backport this PR to: 3.9, 3.10.
🐍🍒⛏🤖

GH-27706 is a backport of this pull request to the 3.10 branch.

GH-27707 is a backport of this pull request to the 3.9 branch.