taskito 0.4.0__tar.gz → 0.5.0__tar.gz

{taskito-0.4.0 → taskito-0.5.0}/Cargo.lock

@@ -194,9 +194,9 @@ dependencies = [
 
 [[package]]
 name = "diesel"
-version = "2.3.6"
+version = "2.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b6c2fc184a6fb6ebcf5f9a5e3bbfa84d8fd268cdfcce4ed508979a6259494d"
+checksum = "f4ae09a41a4b89f94ec1e053623da8340d996bc32c6517d325a9daad9b239358"
 dependencies = [
  "bitflags",
  "byteorder",
@@ -693,9 +693,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.21.3"
+version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "openssl-src"
@@ -708,9 +708,9 @@ dependencies = [
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.111"
+version = "0.9.112"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82cab2d520aa75e3c58898289429321eb788c3106963d0dc886ec7a5f4adc321"
+checksum = "57d55af3b3e226502be1526dfdba67ab0e9c96fc293004e79576b2b9edb0dbdb"
 dependencies = [
  "cc",
  "libc",
@@ -1199,9 +1199,20 @@ version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
+[[package]]
+name = "taskito-async"
+version = "0.5.0"
+dependencies = [
+ "async-trait",
+ "crossbeam-channel",
+ "pyo3",
+ "taskito-core",
+ "tokio",
+]
+
 [[package]]
 name = "taskito-core"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "async-trait",
  "chrono",
@@ -1225,11 +1236,12 @@ dependencies = [
 
 [[package]]
 name = "taskito-python"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "async-trait",
  "crossbeam-channel",
  "pyo3",
+ "taskito-async",
  "taskito-core",
  "tokio",
  "uuid",

{taskito-0.4.0 → taskito-0.5.0}/PKG-INFO

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: taskito
-Version: 0.4.0
+Version: 0.5.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -14,6 +13,7 @@ Classifier: Programming Language :: Rust
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Distributed Computing
 Requires-Dist: cloudpickle>=3.0
+Requires-Dist: boto3>=1.20 ; extra == 'aws'
 Requires-Dist: pytest>=7.0 ; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.21 ; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0 ; extra == 'dev'
@@ -25,17 +25,20 @@ Requires-Dist: cryptography ; extra == 'encryption'
 Requires-Dist: fastapi>=0.100.0 ; extra == 'fastapi'
 Requires-Dist: pydantic>=2.0 ; extra == 'fastapi'
 Requires-Dist: flask>=2.0 ; extra == 'flask'
+Requires-Dist: google-cloud-storage>=2.0 ; extra == 'gcs'
 Requires-Dist: msgpack ; extra == 'msgpack'
 Requires-Dist: opentelemetry-api ; extra == 'otel'
 Requires-Dist: opentelemetry-sdk ; extra == 'otel'
 Requires-Dist: prometheus-client ; extra == 'prometheus'
 Requires-Dist: sentry-sdk ; extra == 'sentry'
+Provides-Extra: aws
 Provides-Extra: dev
 Provides-Extra: django
 Provides-Extra: docs
 Provides-Extra: encryption
 Provides-Extra: fastapi
 Provides-Extra: flask
+Provides-Extra: gcs
 Provides-Extra: msgpack
 Provides-Extra: otel
 Provides-Extra: postgres
@@ -44,7 +47,7 @@ Provides-Extra: redis
 Provides-Extra: sentry
 License-File: LICENSE
 Summary: Rust-powered task queue for Python. No broker required.
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Changelog, https://github.com/pratyush618/taskito/blob/master/docs/changelog.md
 Project-URL: Documentation, https://taskito.grigori.in

{taskito-0.4.0 → taskito-0.5.0}/crates/taskito-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "taskito-core"
-version = "0.4.0"
+version = "0.5.0"
 edition = "2021"
 
 [features]

{taskito-0.4.0 → taskito-0.5.0}/crates/taskito-core/src/storage/mod.rs

@@ -344,11 +344,18 @@ macro_rules! impl_storage {
                 worker_id: &str,
                 queues: &str,
                 tags: Option<&str>,
+                resources: Option<&str>,
+                resource_health: Option<&str>,
+                threads: i32,
             ) -> $crate::error::Result<()> {
-                self.register_worker(worker_id, queues, tags)
+                self.register_worker(worker_id, queues, tags, resources, resource_health, threads)
             }
-            fn heartbeat(&self, worker_id: &str) -> $crate::error::Result<()> {
-                self.heartbeat(worker_id)
+            fn heartbeat(
+                &self,
+                worker_id: &str,
+                resource_health: Option<&str>,
+            ) -> $crate::error::Result<()> {
+                self.heartbeat(worker_id, resource_health)
             }
             fn list_workers(
                 &self,
@@ -705,11 +712,28 @@ impl Storage for StorageBackend {
     fn list_circuit_breakers(&self) -> Result<Vec<models::CircuitBreakerRow>> {
         delegate!(self, list_circuit_breakers)
     }
-    fn register_worker(&self, worker_id: &str, queues: &str, tags: Option<&str>) -> Result<()> {
-        delegate!(self, register_worker, worker_id, queues, tags)
+    fn register_worker(
+        &self,
+        worker_id: &str,
+        queues: &str,
+        tags: Option<&str>,
+        resources: Option<&str>,
+        resource_health: Option<&str>,
+        threads: i32,
+    ) -> Result<()> {
+        delegate!(
+            self,
+            register_worker,
+            worker_id,
+            queues,
+            tags,
+            resources,
+            resource_health,
+            threads
+        )
     }
-    fn heartbeat(&self, worker_id: &str) -> Result<()> {
-        delegate!(self, heartbeat, worker_id)
+    fn heartbeat(&self, worker_id: &str, resource_health: Option<&str>) -> Result<()> {
+        delegate!(self, heartbeat, worker_id, resource_health)
     }
     fn list_workers(&self) -> Result<Vec<models::WorkerRow>> {
         delegate!(self, list_workers)

{taskito-0.4.0 → taskito-0.5.0}/crates/taskito-core/src/storage/models.rs

@@ -284,6 +284,9 @@ pub struct WorkerRow {
     pub queues: String,
     pub status: String,
     pub tags: Option<String>,
+    pub resources: Option<String>,
+    pub resource_health: Option<String>,
+    pub threads: i32,
 }
 
 #[derive(Insertable, AsChangeset, Debug)]
@@ -294,6 +297,9 @@ pub struct NewWorkerRow<'a> {
     pub queues: &'a str,
     pub status: &'a str,
     pub tags: Option<&'a str>,
+    pub resources: Option<&'a str>,
+    pub resource_health: Option<&'a str>,
+    pub threads: i32,
 }
 
 // ── Queue State ─────────────────────────────────────────────────

{taskito-0.4.0 → taskito-0.5.0}/crates/taskito-core/src/storage/postgres/mod.rs

@@ -340,6 +340,20 @@ impl PostgresStorage {
             "ALTER TABLE workers ADD COLUMN IF NOT EXISTS tags TEXT",
         );
 
+        // Migration: add resource advertisement columns to workers
+        migration_alter(
+            &mut conn,
+            "ALTER TABLE workers ADD COLUMN IF NOT EXISTS resources TEXT",
+        );
+        migration_alter(
+            &mut conn,
+            "ALTER TABLE workers ADD COLUMN IF NOT EXISTS resource_health TEXT",
+        );
+        migration_alter(
+            &mut conn,
+            "ALTER TABLE workers ADD COLUMN IF NOT EXISTS threads INTEGER NOT NULL DEFAULT 0",
+        );
+
         diesel::sql_query(
             "CREATE TABLE IF NOT EXISTS queue_state (
                 queue_name TEXT PRIMARY KEY,

{taskito-0.4.0 → taskito-0.5.0}/crates/taskito-core/src/storage/postgres/workers.rs

@@ -11,7 +11,15 @@ const DEAD_WORKER_THRESHOLD_MS: i64 = 30_000;
 
 impl PostgresStorage {
     /// Register a new worker or update an existing one.
-    pub fn register_worker(&self, worker_id: &str, queues: &str, tags: Option<&str>) -> Result<()> {
+    pub fn register_worker(
+        &self,
+        worker_id: &str,
+        queues: &str,
+        tags: Option<&str>,
+        resources: Option<&str>,
+        resource_health: Option<&str>,
+        threads: i32,
+    ) -> Result<()> {
         let mut conn = self.conn()?;
         let now = now_millis();
 
@@ -21,6 +29,9 @@ impl PostgresStorage {
             queues,
             status: "active",
             tags,
+            resources,
+            resource_health,
+            threads,
         };
 
         diesel::insert_into(workers::table)
@@ -34,13 +45,16 @@ impl PostgresStorage {
     }
 
     /// Update the heartbeat timestamp for a worker.
-    pub fn heartbeat(&self, worker_id: &str) -> Result<()> {
+    pub fn heartbeat(&self, worker_id: &str, resource_health: Option<&str>) -> Result<()> {
         let mut conn = self.conn()?;
         let now = now_millis();
 
         diesel::update(workers::table)
             .filter(workers::worker_id.eq(worker_id))
-            .set(workers::last_heartbeat.eq(now))
+            .set((
+                workers::last_heartbeat.eq(now),
+                workers::resource_health.eq(resource_health),
+            ))
             .execute(&mut conn)?;
 
         Ok(())

{taskito-0.4.0 → taskito-0.5.0}/crates/taskito-core/src/storage/redis_backend/workers.rs

@@ -8,7 +8,15 @@ use crate::storage::models::WorkerRow;
 const DEAD_WORKER_THRESHOLD_MS: i64 = 30_000;
 
 impl RedisStorage {
-    pub fn register_worker(&self, worker_id: &str, queues: &str, tags: Option<&str>) -> Result<()> {
+    pub fn register_worker(
+        &self,
+        worker_id: &str,
+        queues: &str,
+        tags: Option<&str>,
+        resources: Option<&str>,
+        resource_health: Option<&str>,
+        threads: i32,
+    ) -> Result<()> {
         let mut conn = self.conn()?;
         let now = now_millis();
         let wkey = self.key(&["worker", worker_id]);
@@ -19,19 +27,24 @@ impl RedisStorage {
         pipe.hset(&wkey, "queues", queues);
         pipe.hset(&wkey, "status", "active");
         pipe.hset(&wkey, "tags", tags.unwrap_or(""));
+        pipe.hset(&wkey, "resources", resources.unwrap_or(""));
+        pipe.hset(&wkey, "resource_health", resource_health.unwrap_or(""));
+        pipe.hset(&wkey, "threads", threads);
         pipe.sadd(&wall, worker_id);
         pipe.query::<()>(&mut conn).map_err(map_err)?;
 
         Ok(())
     }
 
-    pub fn heartbeat(&self, worker_id: &str) -> Result<()> {
+    pub fn heartbeat(&self, worker_id: &str, resource_health: Option<&str>) -> Result<()> {
         let mut conn = self.conn()?;
         let now = now_millis();
         let wkey = self.key(&["worker", worker_id]);
 
-        conn.hset::<_, _, _, ()>(&wkey, "last_heartbeat", now)
-            .map_err(map_err)?;
+        let pipe = &mut redis::pipe();
+        pipe.hset(&wkey, "last_heartbeat", now);
+        pipe.hset(&wkey, "resource_health", resource_health.unwrap_or(""));
+        pipe.query::<()>(&mut conn).map_err(map_err)?;
 
         Ok(())
     }
@@ -52,7 +65,8 @@ impl RedisStorage {
                 continue;
             }
 
-            let tags_val = data.get("tags").map(|s| s.as_str()).unwrap_or("");
+            let to_opt =
+                |key: &str| -> Option<String> { data.get(key).filter(|s| !s.is_empty()).cloned() };
 
             rows.push(WorkerRow {
                 worker_id: wid,
@@ -68,11 +82,13 @@ impl RedisStorage {
                     .get("status")
                     .cloned()
                     .unwrap_or_else(|| "active".to_string()),
-                tags: if tags_val.is_empty() {
-                    None
-                } else {
-                    Some(tags_val.to_string())
-                },
+                tags: to_opt("tags"),
+                resources: to_opt("resources"),
+                resource_health: to_opt("resource_health"),
+                threads: data
+                    .get("threads")
+                    .and_then(|s| s.parse().ok())
+                    .unwrap_or(0),
             });
         }
 

{taskito-0.4.0 → taskito-0.5.0}/crates/taskito-core/src/storage/schema.rs

@@ -144,6 +144,9 @@ diesel::table! {
         queues -> Text,
         status -> Text,
         tags -> Nullable<Text>,
+        resources -> Nullable<Text>,
+        resource_health -> Nullable<Text>,
+        threads -> Integer,
     }
 }
 

{taskito-0.4.0 → taskito-0.5.0}/crates/taskito-core/src/storage/sqlite/mod.rs

@@ -340,6 +340,17 @@ impl SqliteStorage {
         // Migration: add tags column to workers
         migration_alter(&mut conn, "ALTER TABLE workers ADD COLUMN tags TEXT");
 
+        // Migration: add resource advertisement columns to workers
+        migration_alter(&mut conn, "ALTER TABLE workers ADD COLUMN resources TEXT");
+        migration_alter(
+            &mut conn,
+            "ALTER TABLE workers ADD COLUMN resource_health TEXT",
+        );
+        migration_alter(
+            &mut conn,
+            "ALTER TABLE workers ADD COLUMN threads INTEGER NOT NULL DEFAULT 0",
+        );
+
         // ── Queue State ──────────────────────────────────
         diesel::sql_query(
             "CREATE TABLE IF NOT EXISTS queue_state (

{taskito-0.4.0 → taskito-0.5.0}/crates/taskito-core/src/storage/sqlite/workers.rs

@@ -11,7 +11,15 @@ const DEAD_WORKER_THRESHOLD_MS: i64 = 30_000;
 
 impl SqliteStorage {
     /// Register a new worker or update an existing one.
-    pub fn register_worker(&self, worker_id: &str, queues: &str, tags: Option<&str>) -> Result<()> {
+    pub fn register_worker(
+        &self,
+        worker_id: &str,
+        queues: &str,
+        tags: Option<&str>,
+        resources: Option<&str>,
+        resource_health: Option<&str>,
+        threads: i32,
+    ) -> Result<()> {
         let mut conn = self.conn()?;
         let now = now_millis();
 
@@ -21,6 +29,9 @@ impl SqliteStorage {
             queues,
             status: "active",
             tags,
+            resources,
+            resource_health,
+            threads,
         };
 
         diesel::replace_into(workers::table)
@@ -31,13 +42,16 @@ impl SqliteStorage {
     }
 
     /// Update the heartbeat timestamp for a worker.
-    pub fn heartbeat(&self, worker_id: &str) -> Result<()> {
+    pub fn heartbeat(&self, worker_id: &str, resource_health: Option<&str>) -> Result<()> {
         let mut conn = self.conn()?;
         let now = now_millis();
 
         diesel::update(workers::table)
             .filter(workers::worker_id.eq(worker_id))
-            .set(workers::last_heartbeat.eq(now))
+            .set((
+                workers::last_heartbeat.eq(now),
+                workers::resource_health.eq(resource_health),
+            ))
             .execute(&mut conn)?;
 
         Ok(())

{taskito-0.4.0 → taskito-0.5.0}/crates/taskito-core/src/storage/traits.rs

@@ -113,8 +113,16 @@ pub trait Storage: Send + Sync + Clone {
 
     // ── Worker operations ───────────────────────────────────────────
 
-    fn register_worker(&self, worker_id: &str, queues: &str, tags: Option<&str>) -> Result<()>;
-    fn heartbeat(&self, worker_id: &str) -> Result<()>;
+    fn register_worker(
+        &self,
+        worker_id: &str,
+        queues: &str,
+        tags: Option<&str>,
+        resources: Option<&str>,
+        resource_health: Option<&str>,
+        threads: i32,
+    ) -> Result<()>;
+    fn heartbeat(&self, worker_id: &str, resource_health: Option<&str>) -> Result<()>;
     fn list_workers(&self) -> Result<Vec<WorkerRow>>;
     fn reap_dead_workers(&self) -> Result<u64>;
     fn unregister_worker(&self, worker_id: &str) -> Result<()>;

{taskito-0.4.0 → taskito-0.5.0}/crates/taskito-core/tests/rust/storage_tests.rs

@@ -162,11 +162,20 @@ fn test_record_and_get_errors(s: &impl Storage) {
 }
 
 fn test_workers(s: &impl Storage) {
-    s.register_worker("w-test-1", "q-workers", None).unwrap();
-    s.heartbeat("w-test-1").unwrap();
+    let resources = Some(r#"["db","redis"]"#);
+    let health = Some(r#"{"db":"healthy","redis":"healthy"}"#);
+
+    s.register_worker("w-test-1", "q-workers", None, resources, health, 4)
+        .unwrap();
+    s.heartbeat("w-test-1", Some(r#"{"db":"unhealthy","redis":"healthy"}"#))
+        .unwrap();
 
     let workers = s.list_workers().unwrap();
     assert!(!workers.is_empty());
+    let w = workers.iter().find(|w| w.worker_id == "w-test-1").unwrap();
+    assert_eq!(w.threads, 4);
+    assert!(w.resources.as_deref().unwrap().contains("db"));
+    assert!(w.resource_health.as_deref().unwrap().contains("unhealthy"));
 
     s.unregister_worker("w-test-1").unwrap();
 }

{taskito-0.4.0 → taskito-0.5.0}/crates/taskito-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "taskito-python"
-version = "0.4.0"
+version = "0.5.0"
 edition = "2021"
 
 [features]
@@ -8,6 +8,7 @@ default = []
 extension-module = ["pyo3/extension-module"]
 postgres = ["taskito-core/postgres"]
 redis = ["taskito-core/redis"]
+native-async = ["dep:taskito-async"]
 
 [lib]
 name = "_taskito"
@@ -20,3 +21,4 @@ tokio = { workspace = true }
 crossbeam-channel = { workspace = true }
 uuid = { workspace = true }
 async-trait = { workspace = true }
+taskito-async = { path = "../taskito-async", optional = true }

{taskito-0.4.0 → taskito-0.5.0}/crates/taskito-python/src/lib.rs

@@ -1,5 +1,6 @@
 use pyo3::prelude::*;
 
+#[cfg(not(feature = "native-async"))]
 mod async_worker;
 mod py_config;
 mod py_job;
@@ -15,5 +16,7 @@ fn _taskito(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyQueue>()?;
     m.add_class::<PyJob>()?;
     m.add_class::<PyTaskConfig>()?;
+    #[cfg(feature = "native-async")]
+    m.add_class::<taskito_async::PyResultSender>()?;
     Ok(())
 }

{taskito-0.4.0 → taskito-0.5.0}/crates/taskito-python/src/py_queue/inspection.rs

@@ -371,6 +371,9 @@ impl PyQueue {
                 dict.set_item("queues", r.queues)?;
                 dict.set_item("status", r.status)?;
                 dict.set_item("tags", r.tags)?;
+                dict.set_item("resources", r.resources)?;
+                dict.set_item("resource_health", r.resource_health)?;
+                dict.set_item("threads", r.threads)?;
                 result.push(dict.into());
             }
             Ok(result)

{taskito-0.4.0 → taskito-0.5.0}/crates/taskito-python/src/py_queue/worker.rs

@@ -11,6 +11,7 @@ use taskito_core::scheduler::{JobResult, Scheduler, SchedulerConfig, TaskConfig}
 use taskito_core::storage::Storage;
 
 use super::PyQueue;
+#[cfg(not(feature = "native-async"))]
 use crate::async_worker::AsyncWorkerPool;
 use crate::py_config::PyTaskConfig;
 
@@ -18,7 +19,21 @@ use crate::py_config::PyTaskConfig;
 #[allow(clippy::useless_conversion)]
 impl PyQueue {
     /// Run the worker loop. This blocks until interrupted.
-    #[pyo3(signature = (task_registry, task_configs, queues=None, drain_timeout_secs=None, tags=None))]
+    ///
+    /// The heartbeat is now driven from Python (see `worker_heartbeat`),
+    /// so the internal Rust heartbeat thread is removed.
+    #[pyo3(signature = (
+        task_registry,
+        task_configs,
+        queues=None,
+        drain_timeout_secs=None,
+        tags=None,
+        worker_id=None,
+        resources=None,
+        threads=1,
+        async_concurrency=100,
+    ))]
+    #[allow(clippy::too_many_arguments)]
     pub fn run_worker(
         &self,
         py: Python<'_>,
@@ -27,6 +42,10 @@ impl PyQueue {
         queues: Option<Vec<String>>,
         drain_timeout_secs: Option<u64>,
         tags: Option<String>,
+        worker_id: Option<String>,
+        resources: Option<String>,
+        threads: i32,
+        #[allow(unused_variables)] async_concurrency: i32,
     ) -> PyResult<()> {
         // Reset shutdown flag for this run
         self.shutdown_flag.store(false, Ordering::SeqCst);
@@ -113,25 +132,39 @@ impl PyQueue {
         let scheduler_arc = Arc::new(scheduler);
         let scheduler_for_dispatch = scheduler_arc.clone();
 
-        // Generate a unique worker ID and register
-        let worker_id = uuid::Uuid::now_v7().to_string();
-        let _ = self
-            .storage
-            .register_worker(&worker_id, &queues_str, tags.as_deref());
-
-        // Start heartbeat thread
-        let heartbeat_storage = self.storage.clone();
-        let heartbeat_worker_id = worker_id.clone();
-        let heartbeat_flag = self.shutdown_flag.clone();
-        let heartbeat_handle = std::thread::spawn(move || {
-            while !heartbeat_flag.load(Ordering::SeqCst) {
-                let _ = heartbeat_storage.heartbeat(&heartbeat_worker_id);
-                let _ = heartbeat_storage.reap_dead_workers();
-                std::thread::sleep(std::time::Duration::from_secs(5));
-            }
-        });
+        // Generate or use the provided worker ID and register
+        let worker_id = worker_id.unwrap_or_else(|| uuid::Uuid::now_v7().to_string());
+        let _ = self.storage.register_worker(
+            &worker_id,
+            &queues_str,
+            tags.as_deref(),
+            resources.as_deref(),
+            None,
+            threads,
+        );
+
+        // Create the async executor for native async tasks (if feature enabled)
+        #[cfg(feature = "native-async")]
+        let async_executor = {
+            let sender = taskito_async::PyResultSender::new(result_tx.clone());
+            Python::with_gil(|py| -> PyResult<Arc<PyObject>> {
+                let sender_obj = pyo3::Py::new(py, sender)?;
+                let mod_ = py.import_bound("taskito.async_support.executor")?;
+                let cls = mod_.getattr("AsyncTaskExecutor")?;
+                let context_mod = py.import_bound("taskito.context")?;
+                let queue_ref = context_mod.getattr("_queue_ref")?;
+                let executor = cls.call1((
+                    sender_obj,
+                    registry_arc.clone_ref(py),
+                    queue_ref,
+                    async_concurrency,
+                ))?;
+                executor.call_method0("start")?;
+                Ok(Arc::new(executor.into_py(py)))
+            })?
+        };
 
-        // Create multi-threaded tokio runtime for scheduler + async worker pool
+        // Create multi-threaded tokio runtime for scheduler + worker pool
         let num_workers = self.num_workers;
         // Move result_tx into the runtime — don't keep a copy in the main thread
         // so result_rx disconnects when all workers are done.
@@ -149,15 +182,29 @@ impl PyQueue {
             };
 
             rt.block_on(async {
-                let pool = AsyncWorkerPool::new(num_workers, registry_arc, filters_arc);
-
                 let scheduler_task = tokio::spawn(async move {
                     scheduler_for_dispatch.run(job_tx).await;
                 });
 
                 let worker_task = tokio::spawn(async move {
                     use taskito_core::worker::WorkerDispatcher;
-                    pool.run(job_rx, result_tx).await;
+
+                    #[cfg(feature = "native-async")]
+                    {
+                        let pool = taskito_async::NativeAsyncPool::new(
+                            num_workers,
+                            registry_arc,
+                            filters_arc,
+                            async_executor,
+                        );
+                        pool.run(job_rx, result_tx).await;
+                    }
+
+                    #[cfg(not(feature = "native-async"))]
+                    {
+                        let pool = AsyncWorkerPool::new(num_workers, registry_arc, filters_arc);
+                        pool.run(job_rx, result_tx).await;
+                    }
                 });
 
                 let _ = tokio::join!(scheduler_task, worker_task);
@@ -245,11 +292,20 @@ impl PyQueue {
         }
 
         let _ = runtime_handle.join();
-        let _ = heartbeat_handle.join();
 
         // Unregister worker on shutdown
         let _ = self.storage.unregister_worker(&worker_id);
 
         Ok(())
     }
+
+    /// Update the heartbeat for a running worker. Called from Python every 5s.
+    #[pyo3(signature = (worker_id, resource_health=None))]
+    pub fn worker_heartbeat(&self, worker_id: &str, resource_health: Option<&str>) -> PyResult<()> {
+        self.storage
+            .heartbeat(worker_id, resource_health)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))?;
+        let _ = self.storage.reap_dead_workers();
+        Ok(())
+    }
 }