python_ast::parser

Function parse_enhanced

Source 
pub fn parse_enhanced(
    input: impl AsRef<str>,
    filename: impl AsRef<str>,
) -> Result<Module>
Expand description

Parses Python code and returns the AST as a Module with improved error handling.

This function accepts any type that can be converted to a string reference, making it flexible for different input types. It provides detailed error information including file location and helpful guidance when parsing fails.

§Arguments

  • input - The Python source code to parse
  • filename - The filename to associate with the parsed code

§Returns

  • CrateResult<Module> - The parsed AST module or a detailed error with location info

§Examples

use python_ast::parse_enhanced;
 
let code = "x = 1 + 2";
let module = parse_enhanced(code, "example.py").unwrap();
Examples found in repository?
examples/async_runtime_example.rs (line 47)
46fn generate_and_display(python_code: &str, options: PythonOptions) {
47    match parse_enhanced(python_code, "example.py") {
48        Ok(ast) => {
49            let ctx = CodeGenContext::Module("example".to_string());
50            let symbols = SymbolTableScopes::new();
51            
52            match ast.to_rust(ctx, options, symbols) {
53                Ok(tokens) => {
54                    let code_str = tokens.to_string();
55                    
56                    // Pretty print key parts
57                    println!("Generated Rust code:");
58                    
59                    // Extract imports
60                    let parts: Vec<&str> = code_str.split(" ; ").collect();
61                    for part in &parts {
62                        if part.starts_with("use ") {
63                            println!("  {}", part.trim());
64                        }
65                    }
66                    
67                    // Find main function
68                    if let Some(main_start) = code_str.find("# [") {
69                        if let Some(main_end) = code_str[main_start..].find("async fn main") {
70                            if let Some(brace) = code_str[main_start + main_end..].find(" {") {
71                                let main_signature = &code_str[main_start..main_start + main_end + brace + 2];
72                                println!("  {}", main_signature.trim());
73                                println!("    // ... main function body ...");
74                                println!("  }}");
75                            }
76                        }
77                    }
78                }
79                Err(e) => {
80                    println!("❌ Code generation failed: {}", e);
81                }
82            }
83        },
84        Err(e) => {
85            println!("❌ AST parsing failed: {}", e);
86        }
87    }
88}