Вот адаптация под питон use pyo3::{wrap_pyfunction, prelude::*}; use calamine::{open_workbook_auto, DataType, Range, Reader}; use

std::fs::File;
use std::io::{BufWriter, Write};
use std::path::PathBuf;
/// Formats the sum of two numbers as string.
/// A Python module implemented in Rust.
#[pymodule]
fn xlsx2csv(_py: Python, m: &PyModule) -> PyResult<()> {
m.add_function(wrap_pyfunction!(make_csv, m)?)?;
Ok(())
}
#[pyfunction]
fn make_csv(py: Python, file: String, separator: Option<String>)-> PyResult<&PyAny> {
println!("Создаём файлы");
//Первый файл
let sce = PathBuf::from(&file);
match sce.extension().and_then(|s: &std::ffi::OsStr| s.to_str()) {
Some("xlsx") | Some("xlsm") | Some("xlsb") | Some("xls") => (),
_ => panic!("Expecting an excel file"),
}

let dest: PathBuf = sce.with_extension("csv");
let mut dest = BufWriter::new(File::create(dest).unwrap());
let mut xl = open_workbook_auto(&file).unwrap();
let range = xl.worksheet_range_at(0).unwrap().unwrap();
let sep = separator.unwrap_or(','.to_string());
let locals = pyo3_asyncio::TaskLocals::with_running_loop(py)?.copy_context(py)?;
return pyo3_asyncio::tokio::future_into_py_with_locals(py, locals.clone(), write_range(&mut dest, range.clone(), sep));
}

async fn write_range<W: Write>(dest: &mut W, range: Range<DataType>, separator: String) -> Result<(), PyErr> {
let n = range.get_size().1 - 1;
for r in range.rows() {
for (i, c) in r.iter().enumerate() {
match *c {
DataType::Empty => Ok(()),
DataType::String(ref s) | DataType::DateTimeIso(ref s) | DataType::DurationIso(ref s) => {
write!(dest, "{}", s)
}
DataType::DateTime(ref s) | DataType::Duration(ref s) => {write!(dest, "{}", s.to_string())}
DataType::Float(ref f) => {
write!(dest, "{}", f)
}

DataType::Int(ref i) => write!(dest, "{}", i),
DataType::Error(ref e) => write!(dest, "{:?}", e),
DataType::Bool(ref b) => write!(dest, "{}", b),
}?;
if i != n {
write!(dest, "{}", separator)?;
}
}
write!(dest, "\r\n")?;
}
Ok(())
}

А что в функции write_range асинхронного, кроме ключевого слова async? Ты знаешь, как он работает?

Скажу честно, я плохо представляю, как работают асинхронные функции. Но в версии для rust или ноды синхронная версия кода работает гораздо медленнее

если что, я её без await тестировал =)

Возможно, стоит разобраться, а уже потом писать статьи на хабр?

Возможно. Ну так что? Асинхронная версия работает быстрее. Чего ещё нужно?)

Нет, асинхронная не будет работает быстрее только потому что она асинхронная

Я, естественно, говорил не про абстрактный пример, а про свой

Ну у него же работает. Какие вопросы? Реальность первичнее теории

Что, кстати, не отменяет того, что ты абсолютно прав

Напомнило. Согласно теории, теория и практика совпадают, но на практике это не так

Судя по сказанному ранее, оно ещё даже не скомпилировалось, чтобы работать. И смотря на код async функции без единого await'а внутри, я сильно сомневаюсь в истинности утверждения про "быстрее"

Минутку, сейчас покажу

Синхронный код всегда быстрее асинхронного, кроме случаев когда синхронный код позволяет себе ждать результатов IO вместо того чтобы заняться чем-нибудь полезнее.

вот оно как, спасибо за совет. Судя по всему, я фатально ошибся с тестированием программы, из-за чего возникло ложное представление о силе синхронного кода