feat: add support for connected event handling and custom exceptions

Author: krypton-byte

python/tryx/exceptions.py

@@ -0,0 +1,18 @@
+class BuildBotError(Exception):
+    """Raised when the bot fails to build properly."""
+    pass
+
+
+class FailedToDecodeProtoError(Exception):
+    """Raised when the bot fails to decode a protocol buffer."""
+    pass
+
+
+class UnsupportedEventTypeError(Exception):
+    """Raised when an unsupported event type is encountered."""
+    pass
+
+
+class UnsupportedBackendError(Exception):
+    """Raised when an unsupported backend is encountered."""
+    pass

src/client.rs

@@ -21,7 +21,8 @@ use tracing::{debug, error, info, warn};
 use tracing_subscriber::EnvFilter;
 
 use crate::backend::{SqliteBackend, BackendBase};
-use crate::events::{Message as WAMessage, PairingQrCode};
+use crate::events::{Connected, Message as WAMessage, PairingQrCode};
+use crate::exceptions::UnsupportedBackend;
 use crate::types::JID;
 use crate::dispatcher::Dispatcher;
 
@@ -192,6 +193,17 @@ impl Tryx {
                                 }
                             }
                         }
+                        Event::Connected(_) => {
+                            let callbacks = Python::attach(|py| handlers.clone_ref(py).bind(py).borrow().conneccted_handlers(py));
+                            for (idx, callback) in callbacks.into_iter().enumerate() {
+                                debug!(handler_index = idx, "calling connected event handler");
+                                let _ = Python::attach(|py| -> PyResult<_> {
+                                    let awaitable = callback.bind(py).call1((Connected{},))?;
+                                    let fut = into_future(awaitable)?;
+                                    Ok(fut)
+                                });
+                            }
+                        }
                         _ => {
                             debug!("received event without registered dispatcher path");
                         }
@@ -254,7 +266,7 @@ impl Tryx {
             })
         } else {
             error!("unsupported backend type passed to Tryx");
-            Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>("Unsupported backend type"))
+            Err(PyErr::new::<UnsupportedBackend, _>("Unsupported backend type"))
         }
     }
     fn get_client(&self, py: Python<'_>) -> Py<TryxClient> {

src/dispatcher.rs

@@ -3,6 +3,7 @@ use tracing::{debug, info};
 use pyo3::types::{PyType};
 use pyo3::{PyTypeInfo};
 use crate::events::{Connected, Disconnected, LoggedOut, PairSuccess, PairError, PairingCode, PairingQrCode, QrScannedWithoutMultidevice, ClientOutDated, Message};
+use crate::exceptions::UnsupportedEventType;
 
 #[pyclass]
 pub struct Dispatcher {
@@ -116,6 +117,14 @@ impl Dispatcher {
         debug!(handlers = handlers.len(), "collected message handlers");
         handlers
     }
+    pub fn conneccted_handlers(&self, py: Python<'_>) -> Vec<Py<PyAny>> {
+        let handlers = self.connected
+            .iter()
+            .map(|handler| handler.clone_ref(py))
+            .collect::<Vec<_>>();
+        debug!(handlers = handlers.len(), "collected connected handlers");
+        handlers
+    }
     fn handlers_for_event(&self, event: DispatchEvent) -> &Vec<Py<PyAny>> {
         match event {
             DispatchEvent::Connected => &self.connected,
@@ -172,7 +181,8 @@ fn dispatch_event_from_type(py: Python, event_type: &Bound<PyAny>) -> PyResult<D
     } else if event_type.is_subclass(&Message::type_object(py))? {
         Ok(DispatchEvent::Message)
     } else {
-        Err(pyo3::exceptions::PyValueError::new_err("Unsupported event type"))
+        Err(PyErr::new::<UnsupportedEventType, _>("Unsupported event type"))
+
     }
 }
 

src/exceptions.rs

@@ -0,0 +1,77 @@
+use pyo3::{pyclass, pymethods};
+use pyo3::exceptions::PyException;
+#[pyclass(extends=PyException)]
+pub struct FailedBuildBot {
+    message: String,
+}
+
+#[pymethods]
+impl FailedBuildBot {
+    #[new]
+    fn new(message: String) -> Self {
+        FailedBuildBot { message }
+    }
+    fn __str__(&self) -> String {
+        self.message.clone()
+    }
+    fn __repr__(&self) -> String {
+        format!("FailedBuildBot(message='{}')", self.message)
+    }
+}
+
+#[pyclass(extends=PyException)]
+struct FailedToDecodeProto {
+    message: String,
+}
+
+#[pymethods]
+impl FailedToDecodeProto {
+    #[new]
+    fn new(message: String) -> Self {
+        FailedToDecodeProto { message }
+    }
+    fn __str__(&self) -> String {
+        self.message.clone()
+    }
+    fn __repr__(&self) -> String {
+        format!("FailedToDecodeProto(message='{}')", self.message)
+    }
+}
+
+#[pyclass(extends=PyException)]
+pub struct UnsupportedEventType {
+    pub message: String,
+}
+
+#[pymethods]
+impl UnsupportedEventType {
+    #[new]
+    fn new(message: String) -> Self {
+        UnsupportedEventType { message }
+    }
+    fn __str__(&self) -> String {
+        self.message.clone()
+    }
+    fn __repr__(&self) -> String {
+        format!("UnsupportedEventType(message='{}')", self.message)
+    }
+}
+
+#[pyclass(extends=PyException)]
+pub struct UnsupportedBackend {
+    message: String,
+}
+
+#[pymethods]
+impl UnsupportedBackend {
+    #[new]
+    fn new(message: String) -> Self {
+        UnsupportedBackend { message }
+    }
+    fn __str__(&self) -> String {
+        self.message.clone()
+    }
+    fn __repr__(&self) -> String {
+        format!("UnsupportedBackend(message='{}')", self.message)
+    }
+}

src/lib.rs

@@ -31,4 +31,5 @@ mod backend;
 mod client;
 mod events;
 mod types;
-mod dispatcher;
+mod dispatcher;
+mod exceptions;

src/main.rs

@@ -22,6 +22,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 }
                 Event::Message(msg, info) => {
                     println!("Message from {}: {:?}", info.source.sender, msg);
+                }
+                 Event::Connected(e)=> {
+                    println!("Connected to WhatsApp");
                 }
                 _ => {}
             }