Enum PyStmt 

pub enum PyStmt {
    Expr(PyExpr),
    Assign {
        target: PyExpr,
        value: PyExpr,
    },
    AugAssign {
        target: PyExpr,
        op: BinOp,
        value: PyExpr,
    },
    AnnAssign {
        target: PyExpr,
        annotation: TypeAnnotation,
        value: Option<PyExpr>,
    },
    FunctionDef {
        name: String,
        params: Vec<FunctionParam>,
        body: Vec<PyStmt>,
        return_type: Option<TypeAnnotation>,
        decorators: Vec<PyExpr>,
        is_async: bool,
    },
    Return {
        value: Option<PyExpr>,
    },
    If {
        test: PyExpr,
        body: Vec<PyStmt>,
        orelse: Vec<PyStmt>,
    },
    While {
        test: PyExpr,
        body: Vec<PyStmt>,
        orelse: Vec<PyStmt>,
    },
    For {
        target: PyExpr,
        iter: PyExpr,
        body: Vec<PyStmt>,
        orelse: Vec<PyStmt>,
    },
    Pass,
    Break,
    Continue,
    ClassDef {
        name: String,
        bases: Vec<PyExpr>,
        body: Vec<PyStmt>,
        decorators: Vec<PyExpr>,
    },
    Import {
        modules: Vec<(String, Option<String>)>,
    },
    ImportFrom {
        module: Option<String>,
        names: Vec<(String, Option<String>)>,
        level: usize,
    },
    Assert {
        test: PyExpr,
        msg: Option<PyExpr>,
    },
    Try {
        body: Vec<PyStmt>,
        handlers: Vec<ExceptHandler>,
        orelse: Vec<PyStmt>,
        finalbody: Vec<PyStmt>,
    },
    Raise {
        exception: Option<PyExpr>,
    },
    With {
        items: Vec<WithItem>,
        body: Vec<PyStmt>,
    },
    Delete {
        targets: Vec<PyExpr>,
    },
    Global {
        names: Vec<String>,
    },
    Nonlocal {
        names: Vec<String>,
    },
}

Python statement types

Variants

Expr(PyExpr)

Expression statement

Assign

Assignment: x = 42

Fields

target: PyExpr

value: PyExpr

AugAssign

Augmented assignment: x += 1

Fields

target: PyExpr

op: BinOp

value: PyExpr

AnnAssign

Annotated assignment: x: int = 42

Fields

target: PyExpr

annotation: TypeAnnotation

value: Option<PyExpr>

FunctionDef

Function definition

Fields

name: String

params: Vec<FunctionParam>

body: Vec<PyStmt>

return_type: Option<TypeAnnotation>

decorators: Vec<PyExpr>

is_async: bool

Return

Return statement

Fields

value: Option<PyExpr>

If

If statement

Fields

test: PyExpr

body: Vec<PyStmt>

orelse: Vec<PyStmt>

While

While loop

Fields

test: PyExpr

body: Vec<PyStmt>

orelse: Vec<PyStmt>

For

For loop

Fields

target: PyExpr

iter: PyExpr

body: Vec<PyStmt>

orelse: Vec<PyStmt>

Pass

Pass statement

Break

Break statement

Continue

Continue statement

ClassDef

Class definition

Fields

name: String

bases: Vec<PyExpr>

body: Vec<PyStmt>

decorators: Vec<PyExpr>

Import

Import statement: import module [as alias]

Fields

modules: Vec<(String, Option<String>)>

ImportFrom

From import: from module import name [as alias]

Fields

module: Option<String>

names: Vec<(String, Option<String>)>

level: usize

Assert

Assert statement: assert condition, message

Fields

test: PyExpr

msg: Option<PyExpr>

Try

Try-except statement

Fields

body: Vec<PyStmt>

handlers: Vec<ExceptHandler>

orelse: Vec<PyStmt>

finalbody: Vec<PyStmt>

Raise

Raise statement

Fields

exception: Option<PyExpr>

With

With statement (context manager)

Fields

items: Vec<WithItem>

body: Vec<PyStmt>

Delete

Delete statement: del x

Fields

targets: Vec<PyExpr>

Global

Global declaration: global x, y

Fields

names: Vec<String>

Nonlocal

Nonlocal declaration: nonlocal x, y

Fields

names: Vec<String>

Trait Implementations

impl Clone for PyStmt

fn clone(&self) -> PyStmt

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PyStmt

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PyStmt

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PyStmt

fn eq(&self, other: &PyStmt) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for PyStmt

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PyStmt