The trait Termination is not implemented for String

[brandons209]

Hello, I am trying to convert a function from an existing rust program to a pyfunction such that I can call it from Python. However, when I set it up to return a String as a PyResult I am getting the error in the title.

Note: I am extremely new to Rust, so it may be I just have no idea what I am doing with this. Any help is appreciated as I've been stuck for a bit trying to get this work.

See below for a screenshot of the error.

Here is the code:

use std::env;
use std::fs;

use main_error::MainError;
pub use tf_demo_parser::{Demo, DemoParser, Parse, ParseError, ParserState, Stream};
use tf_demo_parser::demo::parser::player_summary_analyzer::PlayerSummaryAnalyzer;

use pyo3::prelude::*;
use pyo3::wrap_pyfunction;
use pyo3::types::PyString;
use std::process::Termination;
use std::process::ExitCode;

#[cfg(feature = "jemallocator")]
#[global_allocator]
static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;



#[pyfunction]
fn main(path: String) -> PyResult<String> {
    #[cfg(feature = "better_panic")]
    better_panic::install();

    #[cfg(feature = "trace")]
    tracing_subscriber::fmt::init();

    // let all = args.contains(&std::string::String::from("all"));
    // let detailed_summaries = args.contains(&std::string::String::from("detailed_summaries"));
    let file = fs::read(path)?;
    let demo = Demo::new(&file);

    // if !detailed_summaries {
        // Use the default (simple) analyzer to track kills, assists, and deaths
    //    let parser = if all {
    //        DemoParser::new_all(demo.get_stream())
    //    } else {
    //        DemoParser::new(demo.get_stream())
    //    };
    //    let (_, state) = parser.parse()?;
    //    return state.to_string()
    // } else {
    let parser = DemoParser::new_with_analyser(demo.get_stream(), PlayerSummaryAnalyzer::new());
    let (header, state) = parser.parse()?;

    // println!("{:?}", header);

    let table_header = "player,points,kills,deaths,assists,destruction,captures,defenses,domination,revenge,ubers,headshots,teleports,healing,backstabs,bonus,support,damage";
    // let divider      = "---------------------------------|------------|------------|------------|------------|-------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|-------------";
    // println!("{}", table_header);
    // println!("{}", divider);

    let data = "";
    for (user_id, user_data) in state.users {
        let player_name = user_data.name;
        let summary = state.player_summaries.get(&user_id);
        match summary {
            Some(s) => {
                data += format!(
                    "{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}\n",
                    player_name,
                    s.points,
                    s.kills,
                    s.deaths,
                    s.assists,
                    s.buildings_destroyed,
                    s.captures,
                    s.defenses,
                    s.dominations,
                    s.revenges,
                    s.ubercharges,
                    s.headshots,
                    s.teleports,
                    s.healing,
                    s.backstabs,
                    s.bonus_points,
                    s.support,
                    s.damage_dealt,
                );
            },
            None => {
                // No summary for this player - they likely joined at the end of the match, or left before they did anything noteworthy
            }
        }
    }

    return header.to_string() + "\n" + table_header + "\n" + data
}

/// A Python module implemented in Rust. The name of this function must match
/// the `lib.name` setting in the `Cargo.toml`, else Python will not be able to
/// import the module.
#[pymodule]
#[pyo3(name = "tf_demo_parser")]
fn tf_demo_parser(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(main, m)?)?;
    Ok(())
}

If you want to view the original repo here it is: https://github.com/demostf/parser

[davidhewitt]

main is a special function name so the Rust compiler is applying special handling to it.

Try the following instead, which uses a different name in Python than in Rust:

#[pyfunction(name="main")]
fn py_main(

[brandons209]

Great, thanks! That seem to did the trick.