ThreadPoolExecutor

[AriBermeki]

@davidhewitt
that was a good attempt with Python 3.12 😆😆🤣🤣🤣🤣🤣🤣🤣🤣🤣

use pyo3::prelude::*;
use threadpool::ThreadPool;




#[pyclass]
struct NextThreadPoolExecutor{
    thread:ThreadPool
}

#[pymethods]
impl NextThreadPoolExecutor {
    #[new]
    pub fn new(
        num_threads:usize
    )->PyResult<Self>{
        let pool = ThreadPool::new(num_threads);

        Ok(
            NextThreadPoolExecutor{thread:pool}
        )
    }


    pub fn active_count(&self)->PyResult<()>{
        // Returns the number of currently active threads.
       self.thread.active_count();
       Ok(())
    }

    pub fn execute(&self, job: Py<PyAny>) -> PyResult<()> {
        // Executes the function job on a thread in the pool.
        self.thread.execute(move || {
            // Acquire the GIL inside the thread.
            Python::with_gil(|py| {
                if let Err(err) = job.call0(py) {
                    eprintln!("Job execution failed: {:?}", err);
                }
            });
        });
    
        Ok(())
    }
    
    pub fn join(&self)->PyResult<()>{
     
        // Block the current thread until all jobs in the pool have been executed.
        // Calling join on an empty pool will cause an immediate return. join may be called from multiple threads concurrently. 
        // A join is an atomic point in time. 
        // All threads joining before the join event will exit together even if the pool is processing new jobs by the time they get scheduled.
        //  Calling join from a thread within the pool will cause a deadlock. This behavior is considered safe.
       self.thread.join();
       Ok(())
    }

    pub fn max_count(&self)->PyResult<()>{
        //Returns the maximum number of threads the pool will execute concurrently.


       self.thread.max_count();
       Ok(())
    }


    pub fn failed_threads_count(&self)->PyResult<()>{
        // Returns the number of panicked threads over the lifetime of the pool.
       self.thread.panic_count();
       Ok(())
    }

    pub fn set_num_threads(&mut self, num_threads: usize)->PyResult<()>{
        // Sets the number of worker-threads to use as num_threads. Can be used to change the threadpool size during runtime. 
        // Will not abort already running or waiting threads.
       self.thread.set_num_threads(num_threads);
       Ok(())
    }

}



/// A Python module implemented in Rust.
#[pymodule]
fn py_executor(m: &Bound<'_, PyModule>) -> PyResult<()> {
    // m.add_function(wrap_pyfunction!(rust_thread_pool_executor, m)?)?;
    m.add_class::<NextThreadPoolExecutor>()?;
    Ok(())
}

[jahvinWVR]

why did u cover some stuf up