rustpython-parser 0.4.0

---
source: parser/src/parser.rs
expression: parse_ast
---
[
    TryStar(
        StmtTryStar {
            range: 0..260,
            body: [
                Raise(
                    StmtRaise {
                        range: 9..98,
                        exc: Some(
                            Call(
                                ExprCall {
                                    range: 15..98,
                                    func: Name(
                                        ExprName {
                                            range: 15..29,
                                            id: Identifier(
                                                "ExceptionGroup",
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                    args: [
                                        Constant(
                                            ExprConstant {
                                                range: 30..34,
                                                value: Str(
                                                    "eg",
                                                ),
                                                kind: None,
                                            },
                                        ),
                                        List(
                                            ExprList {
                                                range: 44..97,
                                                elts: [
                                                    Call(
                                                        ExprCall {
                                                            range: 45..58,
                                                            func: Name(
                                                                ExprName {
                                                                    range: 45..55,
                                                                    id: Identifier(
                                                                        "ValueError",
                                                                    ),
                                                                    ctx: Load,
                                                                },
                                                            ),
                                                            args: [
                                                                Constant(
                                                                    ExprConstant {
                                                                        range: 56..57,
                                                                        value: Int(
                                                                            1,
                                                                        ),
                                                                        kind: None,
                                                                    },
                                                                ),
                                                            ],
                                                            keywords: [],
                                                        },
                                                    ),
                                                    Call(
                                                        ExprCall {
                                                            range: 60..72,
                                                            func: Name(
                                                                ExprName {
                                                                    range: 60..69,
                                                                    id: Identifier(
                                                                        "TypeError",
                                                                    ),
                                                                    ctx: Load,
                                                                },
                                                            ),
                                                            args: [
                                                                Constant(
                                                                    ExprConstant {
                                                                        range: 70..71,
                                                                        value: Int(
                                                                            2,
                                                                        ),
                                                                        kind: None,
                                                                    },
                                                                ),
                                                            ],
                                                            keywords: [],
                                                        },
                                                    ),
                                                    Call(
                                                        ExprCall {
                                                            range: 74..84,
                                                            func: Name(
                                                                ExprName {
                                                                    range: 74..81,
                                                                    id: Identifier(
                                                                        "OSError",
                                                                    ),
                                                                    ctx: Load,
                                                                },
                                                            ),
                                                            args: [
                                                                Constant(
                                                                    ExprConstant {
                                                                        range: 82..83,
                                                                        value: Int(
                                                                            3,
                                                                        ),
                                                                        kind: None,
                                                                    },
                                                                ),
                                                            ],
                                                            keywords: [],
                                                        },
                                                    ),
                                                    Call(
                                                        ExprCall {
                                                            range: 86..96,
                                                            func: Name(
                                                                ExprName {
                                                                    range: 86..93,
                                                                    id: Identifier(
                                                                        "OSError",
                                                                    ),
                                                                    ctx: Load,
                                                                },
                                                            ),
                                                            args: [
                                                                Constant(
                                                                    ExprConstant {
                                                                        range: 94..95,
                                                                        value: Int(
                                                                            4,
                                                                        ),
                                                                        kind: None,
                                                                    },
                                                                ),
                                                            ],
                                                            keywords: [],
                                                        },
                                                    ),
                                                ],
                                                ctx: Load,
                                            },
                                        ),
                                    ],
                                    keywords: [],
                                },
                            ),
                        ),
                        cause: None,
                    },
                ),
            ],
            handlers: [
                ExceptHandler(
                    ExceptHandlerExceptHandler {
                        range: 99..180,
                        type_: Some(
                            Name(
                                ExprName {
                                    range: 107..116,
                                    id: Identifier(
                                        "TypeError",
                                    ),
                                    ctx: Load,
                                },
                            ),
                        ),
                        name: Some(
                            Identifier(
                                "e",
                            ),
                        ),
                        body: [
                            Expr(
                                StmtExpr {
                                    range: 127..180,
                                    value: Call(
                                        ExprCall {
                                            range: 127..180,
                                            func: Name(
                                                ExprName {
                                                    range: 127..132,
                                                    id: Identifier(
                                                        "print",
                                                    ),
                                                    ctx: Load,
                                                },
                                            ),
                                            args: [
                                                JoinedStr(
                                                    ExprJoinedStr {
                                                        range: 133..179,
                                                        values: [
                                                            Constant(
                                                                ExprConstant {
                                                                    range: 133..179,
                                                                    value: Str(
                                                                        "caught ",
                                                                    ),
                                                                    kind: None,
                                                                },
                                                            ),
                                                            FormattedValue(
                                                                ExprFormattedValue {
                                                                    range: 133..179,
                                                                    value: Call(
                                                                        ExprCall {
                                                                            range: 143..150,
                                                                            func: Name(
                                                                                ExprName {
                                                                                    range: 143..147,
                                                                                    id: Identifier(
                                                                                        "type",
                                                                                    ),
                                                                                    ctx: Load,
                                                                                },
                                                                            ),
                                                                            args: [
                                                                                Name(
                                                                                    ExprName {
                                                                                        range: 148..149,
                                                                                        id: Identifier(
                                                                                            "e",
                                                                                        ),
                                                                                        ctx: Load,
                                                                                    },
                                                                                ),
                                                                            ],
                                                                            keywords: [],
                                                                        },
                                                                    ),
                                                                    conversion: None,
                                                                    format_spec: None,
                                                                },
                                                            ),
                                                            Constant(
                                                                ExprConstant {
                                                                    range: 133..179,
                                                                    value: Str(
                                                                        " with nested ",
                                                                    ),
                                                                    kind: None,
                                                                },
                                                            ),
                                                            FormattedValue(
                                                                ExprFormattedValue {
                                                                    range: 133..179,
                                                                    value: Attribute(
                                                                        ExprAttribute {
                                                                            range: 165..177,
                                                                            value: Name(
                                                                                ExprName {
                                                                                    range: 165..166,
                                                                                    id: Identifier(
                                                                                        "e",
                                                                                    ),
                                                                                    ctx: Load,
                                                                                },
                                                                            ),
                                                                            attr: Identifier(
                                                                                "exceptions",
                                                                            ),
                                                                            ctx: Load,
                                                                        },
                                                                    ),
                                                                    conversion: None,
                                                                    format_spec: None,
                                                                },
                                                            ),
                                                        ],
                                                    },
                                                ),
                                            ],
                                            keywords: [],
                                        },
                                    ),
                                },
                            ),
                        ],
                    },
                ),
                ExceptHandler(
                    ExceptHandlerExceptHandler {
                        range: 181..260,
                        type_: Some(
                            Name(
                                ExprName {
                                    range: 189..196,
                                    id: Identifier(
                                        "OSError",
                                    ),
                                    ctx: Load,
                                },
                            ),
                        ),
                        name: Some(
                            Identifier(
                                "e",
                            ),
                        ),
                        body: [
                            Expr(
                                StmtExpr {
                                    range: 207..260,
                                    value: Call(
                                        ExprCall {
                                            range: 207..260,
                                            func: Name(
                                                ExprName {
                                                    range: 207..212,
                                                    id: Identifier(
                                                        "print",
                                                    ),
                                                    ctx: Load,
                                                },
                                            ),
                                            args: [
                                                JoinedStr(
                                                    ExprJoinedStr {
                                                        range: 213..259,
                                                        values: [
                                                            Constant(
                                                                ExprConstant {
                                                                    range: 213..259,
                                                                    value: Str(
                                                                        "caught ",
                                                                    ),
                                                                    kind: None,
                                                                },
                                                            ),
                                                            FormattedValue(
                                                                ExprFormattedValue {
                                                                    range: 213..259,
                                                                    value: Call(
                                                                        ExprCall {
                                                                            range: 223..230,
                                                                            func: Name(
                                                                                ExprName {
                                                                                    range: 223..227,
                                                                                    id: Identifier(
                                                                                        "type",
                                                                                    ),
                                                                                    ctx: Load,
                                                                                },
                                                                            ),
                                                                            args: [
                                                                                Name(
                                                                                    ExprName {
                                                                                        range: 228..229,
                                                                                        id: Identifier(
                                                                                            "e",
                                                                                        ),
                                                                                        ctx: Load,
                                                                                    },
                                                                                ),
                                                                            ],
                                                                            keywords: [],
                                                                        },
                                                                    ),
                                                                    conversion: None,
                                                                    format_spec: None,
                                                                },
                                                            ),
                                                            Constant(
                                                                ExprConstant {
                                                                    range: 213..259,
                                                                    value: Str(
                                                                        " with nested ",
                                                                    ),
                                                                    kind: None,
                                                                },
                                                            ),
                                                            FormattedValue(
                                                                ExprFormattedValue {
                                                                    range: 213..259,
                                                                    value: Attribute(
                                                                        ExprAttribute {
                                                                            range: 245..257,
                                                                            value: Name(
                                                                                ExprName {
                                                                                    range: 245..246,
                                                                                    id: Identifier(
                                                                                        "e",
                                                                                    ),
                                                                                    ctx: Load,
                                                                                },
                                                                            ),
                                                                            attr: Identifier(
                                                                                "exceptions",
                                                                            ),
                                                                            ctx: Load,
                                                                        },
                                                                    ),
                                                                    conversion: None,
                                                                    format_spec: None,
                                                                },
                                                            ),
                                                        ],
                                                    },
                                                ),
                                            ],
                                            keywords: [],
                                        },
                                    ),
                                },
                            ),
                        ],
                    },
                ),
            ],
            orelse: [],
            finalbody: [],
        },
    ),
]