Refactor code structure for improved readability and maintainability

Author: krypton-byte

Cargo.lock

@@ -1,11 +1,11 @@
 [package]
-name = "karat"
+name = "tryx"
 version = "0.1.0"
 edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]
-name = "karat"
+name = "tryx"
 crate-type = ["cdylib"]
 
 [dependencies]

Cargo.toml

@@ -3,7 +3,7 @@ requires = ["maturin>=1.12,<2.0"]
 build-backend = "maturin"
 
 [project]
-name = "karat"
+name = "tryx"
 requires-python = ">=3.8"
 classifiers = [
     "Programming Language :: Rust",
@@ -13,4 +13,14 @@ classifiers = [
 dynamic = ["version"]
 
 [tool.maturin]
-module-name = "karat._karat"
+module-name = "tryx.tryx"
+python-source = "python"
+
+[dependency-groups]
+dev = [
+    "mypy-protobuf>=5.0.0",
+]
+# include = [
+#     { path = "python/tryx/__init__.py", format = ["sdist", "wheel"] },
+#     { path = "python/tryx/yaya.py", format = ["sdist", "wheel"] },
+# ]

pyproject.toml

@@ -0,0 +1,3 @@
+from .yaya import hallo
+
+__all__ = ["hallo"]

python/tryx/__init__.py

@@ -1,7 +1,4 @@
 
-use std::sync::Arc;
-use async_trait::async_trait;
-use whatsapp_rust::store::Backend;
 use whatsapp_rust_sqlite_storage::SqliteStore;
 use pyo3::prelude::*;
 
@@ -13,10 +10,6 @@ pub struct SqliteBackend {
     path: String,
 }
 
-#[pyclass(extends=BackendBase)]
-pub struct PostgresBackend {
-    connection_string: String,
-}
 #[pymethods]
 impl SqliteBackend {
     #[new]
@@ -34,15 +27,3 @@ impl SqliteBackend {
     }
 }
 
-#[pymethods]
-impl PostgresBackend {
-    #[new]
-    fn new(connection_string: String) -> (Self, BackendBase) {
-        (PostgresBackend { connection_string }, BackendBase)
-    }
-}
-pub enum BackendType {
-    Sqlite(SqliteBackend),
-    Postgres(PostgresBackend)
-}
-

python/tryx/tryx.pyi

@@ -1,7 +1,5 @@
-use std::any::Any;
-use std::{ sync::Arc};
-use pyo3::exceptions::PyException;
-use pyo3::{pyclass, pymethods};
+use std::sync::Arc;
+use pyo3::{Bound, PyAny, pyclass, pymethods};
 use pyo3::prelude::*;
 use pyo3_async_runtimes::async_std::future_into_py;
 use tokio::runtime;
@@ -11,26 +9,43 @@ use whatsapp_rust::store::Backend;
 use whatsapp_rust_tokio_transport::TokioWebSocketTransportFactory;
 use whatsapp_rust_ureq_http_client::UreqHttpClient;
 
-use crate::backend::{BackendType, SqliteBackend, BackendBase};
+use crate::backend::{SqliteBackend, BackendBase};
+use crate::events::Dispatcher;
 
 #[pyclass]
-struct KaratClient {
+pub struct Tryx {
     backend: Arc<dyn Backend>,
+    handlers: Py<Dispatcher>,
 }
 
 #[pymethods]
-impl KaratClient {
+impl Tryx {
     #[new]
     fn new(py: Python, backend: Py<BackendBase>) -> PyResult<Self> {
         if let Ok(sqlite) = backend.extract::<Py<SqliteBackend>>(py) {
             let backends = sqlite.borrow(py);
             let store = runtime::Runtime::new().unwrap().block_on(backends.connect()).map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e))?;
             // let store = sqlite_backend.connect().await.map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e))?;
-            Ok(KaratClient { backend: Arc::new(store)})
+            Ok(Tryx {
+                backend: Arc::new(store),
+                handlers: Py::new(py, Dispatcher::empty())?,
+            })
         } else {
             Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>("Unsupported backend type"))
         }
     }
+
+    /// Returns a decorator compatible with:
+    /// @client.on(Message)
+    /// async def on_message(client, data): ...
+    fn on(&self, py: Python, event_type: &Bound<PyAny>) -> PyResult<Py<PyAny>> {
+        let decorator = self
+            .handlers
+            .bind(py)
+            .call_method1("on", (event_type,))?;
+        Ok(decorator.unbind())
+    }
+
     fn run<'py>(&'py self, py: Python<'py> ) -> Result<Bound<PyAny>, PyErr> {
         // Here you would implement the logic to run the bot using the backend
         let backend = self.backend.clone();
@@ -50,7 +65,7 @@ impl KaratClient {
                     }
                 })
                 .build();
-            bot.await.map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))?.run().await. .map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))?.await.map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))?;
+            // bot.await.map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))?.run().await. .map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))?.await.map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))?;
             Ok(())
         })
     }