LISTEN/NOTIFY funcionality

chandr-andr · chandr-andr · commit 007296d1ace9 · 2025-01-25T16:08:09.000+01:00
Signed-off-by: chandr-andr (Kiselev Aleksandr) &lt;chandr@chandr.net&gt;
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -58,8 +58,6 @@ repos:
           - clippy::all
           - -W
           - clippy::pedantic
-          - -D
-          - warnings
 
       - id: check
         types:
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -10,15 +10,8 @@ crate-type = ["cdylib"]
 
 [dependencies]
 deadpool-postgres = { git = "https://github.com/chandr-andr/deadpool.git", branch = "psqlpy" }
-pyo3 = { version = "*", features = [
-    "chrono",
-    "experimental-async",
-    "rust_decimal",
-    "py-clone",
-    "gil-refs",
-    "macros",
-] }
-pyo3-async-runtimes = { git = "https://github.com/chandr-andr/pyo3-async-runtimes.git", branch = "main", features = [
+pyo3 = { version = "0.23.4", features = ["chrono", "experimental-async", "rust_decimal", "py-clone", "macros"] }
+pyo3-async-runtimes = { git = "https://github.com/chandr-andr/pyo3-async-runtimes.git", branch = "psqlpy", features = [
     "tokio-runtime",
 ] }
 
diff --git a/src/common.rs b/src/common.rs
@@ -24,10 +24,10 @@ pub fn add_module(
     child_mod_name: &'static str,
     child_mod_builder: impl FnOnce(Python<'_>, &Bound<'_, PyModule>) -> PyResult<()>,
 ) -> PyResult<()> {
-    let sub_module = PyModule::new_bound(py, child_mod_name)?;
+    let sub_module = PyModule::new(py, child_mod_name)?;
     child_mod_builder(py, &sub_module)?;
     parent_mod.add_submodule(&sub_module)?;
-    py.import_bound("sys")?.getattr("modules")?.set_item(
+    py.import("sys")?.getattr("modules")?.set_item(
         format!("{}.{}", parent_mod.name()?, child_mod_name),
         sub_module,
     )?;
diff --git a/src/driver/connection.rs b/src/driver/connection.rs
@@ -177,7 +177,7 @@ impl Connection {
         let (is_exception_none, py_err) = pyo3::Python::with_gil(|gil| {
             (
                 exception.is_none(gil),
-                PyErr::from_value_bound(exception.into_bound(gil)),
+                PyErr::from_value(exception.into_bound(gil)),
             )
         });
 
diff --git a/src/driver/cursor.rs b/src/driver/cursor.rs
@@ -179,7 +179,7 @@ impl Cursor {
                     self_.closed,
                     self_.cursor_name.clone(),
                     exception.is_none(gil),
-                    PyErr::from_value_bound(exception.into_bound(gil)),
+                    PyErr::from_value(exception.into_bound(gil)),
                 )
             });
 
diff --git a/src/driver/listener/core.rs b/src/driver/listener/core.rs
@@ -104,7 +104,7 @@ impl Listener {
             (
                 self_.connection.db_client(),
                 exception.is_none(gil),
-                PyErr::from_value_bound(exception.into_bound(gil)),
+                PyErr::from_value(exception.into_bound(gil)),
             )
         });
 
diff --git a/src/driver/transaction.rs b/src/driver/transaction.rs
@@ -236,7 +236,7 @@ impl Transaction {
                 (
                     self_.check_is_transaction_ready(),
                     exception.is_none(gil),
-                    PyErr::from_value_bound(exception.into_bound(gil)),
+                    PyErr::from_value(exception.into_bound(gil)),
                     self_.db_client.clone(),
                 )
             });
diff --git a/src/driver/utils.rs b/src/driver/utils.rs
@@ -226,7 +226,7 @@ pub fn build_manager(
 /// 2) extract boolean
 pub fn is_coroutine_function(function: Py<PyAny>) -> RustPSQLDriverPyResult<bool> {
     let is_coroutine_function: bool = Python::with_gil(|py| {
-        let inspect = py.import_bound("inspect")?;
+        let inspect = py.import("inspect")?;
 
         let is_cor = inspect
             .call_method1("iscoroutinefunction", (function,))
diff --git a/src/exceptions/python_errors.rs b/src/exceptions/python_errors.rs
@@ -3,6 +3,7 @@ use pyo3::{
     types::{PyModule, PyModuleMethods},
     Bound, PyResult, Python,
 };
+
 // Main exception.
 create_exception!(
     psqlpy.exceptions,
@@ -146,108 +147,93 @@ create_exception!(psqlpy.exceptions, SSLError, RustPSQLDriverPyBaseError);
 pub fn python_exceptions_module(py: Python<'_>, pymod: &Bound<'_, PyModule>) -> PyResult<()> {
     pymod.add(
         "RustPSQLDriverPyBaseError",
-        py.get_type_bound::<RustPSQLDriverPyBaseError>(),
+        py.get_type::<RustPSQLDriverPyBaseError>(),
     )?;
 
     pymod.add(
         "BaseConnectionPoolError",
-        py.get_type_bound::<BaseConnectionPoolError>(),
+        py.get_type::<BaseConnectionPoolError>(),
     )?;
     pymod.add(
         "ConnectionPoolBuildError",
-        py.get_type_bound::<ConnectionPoolBuildError>(),
+        py.get_type::<ConnectionPoolBuildError>(),
     )?;
     pymod.add(
         "ConnectionPoolConfigurationError",
-        py.get_type_bound::<ConnectionPoolConfigurationError>(),
+        py.get_type::<ConnectionPoolConfigurationError>(),
     )?;
     pymod.add(
         "ConnectionPoolExecuteError",
-        py.get_type_bound::<ConnectionPoolExecuteError>(),
+        py.get_type::<ConnectionPoolExecuteError>(),
     )?;
 
-    pymod.add(
-        "BaseConnectionError",
-        py.get_type_bound::<BaseConnectionError>(),
-    )?;
+    pymod.add("BaseConnectionError", py.get_type::<BaseConnectionError>())?;
     pymod.add(
         "ConnectionExecuteError",
-        py.get_type_bound::<ConnectionExecuteError>(),
+        py.get_type::<ConnectionExecuteError>(),
     )?;
     pymod.add(
         "ConnectionClosedError",
-        py.get_type_bound::<ConnectionClosedError>(),
+        py.get_type::<ConnectionClosedError>(),
     )?;
 
     pymod.add(
         "BaseTransactionError",
-        py.get_type_bound::<BaseTransactionError>(),
+        py.get_type::<BaseTransactionError>(),
     )?;
     pymod.add(
         "TransactionBeginError",
-        py.get_type_bound::<TransactionBeginError>(),
+        py.get_type::<TransactionBeginError>(),
     )?;
     pymod.add(
         "TransactionCommitError",
-        py.get_type_bound::<TransactionCommitError>(),
+        py.get_type::<TransactionCommitError>(),
     )?;
     pymod.add(
         "TransactionRollbackError",
-        py.get_type_bound::<TransactionRollbackError>(),
+        py.get_type::<TransactionRollbackError>(),
     )?;
     pymod.add(
         "TransactionSavepointError",
-        py.get_type_bound::<TransactionSavepointError>(),
+        py.get_type::<TransactionSavepointError>(),
     )?;
     pymod.add(
         "TransactionExecuteError",
-        py.get_type_bound::<TransactionExecuteError>(),
+        py.get_type::<TransactionExecuteError>(),
     )?;
     pymod.add(
         "TransactionClosedError",
-        py.get_type_bound::<TransactionClosedError>(),
+        py.get_type::<TransactionClosedError>(),
     )?;
 
-    pymod.add("BaseCursorError", py.get_type_bound::<BaseCursorError>())?;
-    pymod.add("CursorStartError", py.get_type_bound::<CursorStartError>())?;
-    pymod.add("CursorCloseError", py.get_type_bound::<CursorCloseError>())?;
-    pymod.add("CursorFetchError", py.get_type_bound::<CursorFetchError>())?;
-    pymod.add(
-        "CursorClosedError",
-        py.get_type_bound::<CursorClosedError>(),
-    )?;
+    pymod.add("BaseCursorError", py.get_type::<BaseCursorError>())?;
+    pymod.add("CursorStartError", py.get_type::<CursorStartError>())?;
+    pymod.add("CursorCloseError", py.get_type::<CursorCloseError>())?;
+    pymod.add("CursorFetchError", py.get_type::<CursorFetchError>())?;
+    pymod.add("CursorClosedError", py.get_type::<CursorClosedError>())?;
 
     pymod.add(
         "RustToPyValueMappingError",
-        py.get_type_bound::<RustToPyValueMappingError>(),
+        py.get_type::<RustToPyValueMappingError>(),
     )?;
     pymod.add(
         "PyToRustValueMappingError",
-        py.get_type_bound::<PyToRustValueMappingError>(),
+        py.get_type::<PyToRustValueMappingError>(),
     )?;
     pymod.add(
         "UUIDValueConvertError",
-        py.get_type_bound::<UUIDValueConvertError>(),
+        py.get_type::<UUIDValueConvertError>(),
     )?;
     pymod.add(
         "MacAddrConversionError",
-        py.get_type_bound::<MacAddrConversionError>(),
-    )?;
-    pymod.add(
-        "BaseListenerError",
-        py.get_type_bound::<BaseListenerError>(),
-    )?;
-    pymod.add(
-        "ListenerStartError",
-        py.get_type_bound::<ListenerStartError>(),
-    )?;
-    pymod.add(
-        "ListenerClosedError",
-        py.get_type_bound::<ListenerClosedError>(),
+        py.get_type::<MacAddrConversionError>(),
     )?;
+    pymod.add("BaseListenerError", py.get_type::<BaseListenerError>())?;
+    pymod.add("ListenerStartError", py.get_type::<ListenerStartError>())?;
+    pymod.add("ListenerClosedError", py.get_type::<ListenerClosedError>())?;
     pymod.add(
         "ListenerCallbackError",
-        py.get_type_bound::<ListenerCallbackError>(),
+        py.get_type::<ListenerCallbackError>(),
     )?;
     Ok(())
 }
diff --git a/src/query_result.rs b/src/query_result.rs
@@ -16,7 +16,7 @@ fn row_to_dict<'a>(
     postgres_row: &'a Row,
     custom_decoders: &Option<Py<PyDict>>,
 ) -> RustPSQLDriverPyResult<pyo3::Bound<'a, PyDict>> {
-    let python_dict = PyDict::new_bound(py);
+    let python_dict = PyDict::new(py);
     for (column_idx, column) in postgres_row.columns().iter().enumerate() {
         let python_type = postgres_to_py(py, postgres_row, column, column_idx, custom_decoders)?;
         python_dict.set_item(column.name().to_object(py), python_type)?;
@@ -85,7 +85,7 @@ impl PSQLDriverPyQueryResult {
         let mut res: Vec<Py<PyAny>> = vec![];
         for row in &self.inner {
             let pydict: pyo3::Bound<'_, PyDict> = row_to_dict(py, row, &None)?;
-            let convert_class_inst = as_class.call_bound(py, (), Some(&pydict))?;
+            let convert_class_inst = as_class.call(py, (), Some(&pydict))?;
             res.push(convert_class_inst);
         }
 
@@ -109,7 +109,7 @@ impl PSQLDriverPyQueryResult {
         let mut res: Vec<Py<PyAny>> = vec![];
         for row in &self.inner {
             let pydict: pyo3::Bound<'_, PyDict> = row_to_dict(py, row, &custom_decoders)?;
-            let row_factory_class = row_factory.call_bound(py, (pydict,), None)?;
+            let row_factory_class = row_factory.call(py, (pydict,), None)?;
             res.push(row_factory_class);
         }
         Ok(res.to_object(py))
@@ -170,7 +170,7 @@ impl PSQLDriverSinglePyQueryResult {
         as_class: Py<PyAny>,
     ) -> RustPSQLDriverPyResult<Py<PyAny>> {
         let pydict: pyo3::Bound<'_, PyDict> = row_to_dict(py, &self.inner, &None)?;
-        Ok(as_class.call_bound(py, (), Some(&pydict))?)
+        Ok(as_class.call(py, (), Some(&pydict))?)
     }
 
     /// Convert result from database with function passed from Python.
@@ -188,6 +188,6 @@ impl PSQLDriverSinglePyQueryResult {
         custom_decoders: Option<Py<PyDict>>,
     ) -> RustPSQLDriverPyResult<Py<PyAny>> {
         let pydict = row_to_dict(py, &self.inner, &custom_decoders)?.to_object(py);
-        Ok(row_factory.call_bound(py, (pydict,), None)?)
+        Ok(row_factory.call(py, (pydict,), None)?)
     }
 }
diff --git a/src/runtime.rs b/src/runtime.rs
@@ -1,5 +1,5 @@
 use futures_util::Future;
-use pyo3::{IntoPy, Py, PyAny, PyObject, Python};
+use pyo3::{IntoPyObject, Py, PyAny, Python};
 
 use crate::exceptions::rust_errors::RustPSQLDriverPyResult;
 
@@ -21,7 +21,7 @@ pub fn tokio_runtime() -> &'static tokio::runtime::Runtime {
 pub fn rustdriver_future<F, T>(py: Python<'_>, future: F) -> RustPSQLDriverPyResult<Py<PyAny>>
 where
     F: Future<Output = RustPSQLDriverPyResult<T>> + Send + 'static,
-    T: IntoPy<PyObject>,
+    T: for<'py> IntoPyObject<'py>,
 {
     let res =
         pyo3_async_runtimes::tokio::future_into_py(py, async { future.await.map_err(Into::into) })

Original file line number	Diff line number	Diff line change
`@@ -177,7 +177,7 @@ impl Connection {`
`177`	`177`	`let (is_exception_none, py_err) = pyo3::Python::with_gil(\|gil\| {`
`178`	`178`	`(`
`179`	`179`	`exception.is_none(gil),`
`180`		`- PyErr::from_value_bound(exception.into_bound(gil)),`
	`180`	`+ PyErr::from_value(exception.into_bound(gil)),`
`181`	`181`	`)`
`182`	`182`	`});`
`183`	`183`
Original file line number	Diff line number	Diff line change
`@@ -179,7 +179,7 @@ impl Cursor {`
`179`	`179`	`self_.closed,`
`180`	`180`	`self_.cursor_name.clone(),`
`181`	`181`	`exception.is_none(gil),`
`182`		`- PyErr::from_value_bound(exception.into_bound(gil)),`
	`182`	`+ PyErr::from_value(exception.into_bound(gil)),`
`183`	`183`	`)`
`184`	`184`	`});`
`185`	`185`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ impl Listener {`
`104`	`104`	`(`
`105`	`105`	`self_.connection.db_client(),`
`106`	`106`	`exception.is_none(gil),`
`107`		`- PyErr::from_value_bound(exception.into_bound(gil)),`
	`107`	`+ PyErr::from_value(exception.into_bound(gil)),`
`108`	`108`	`)`
`109`	`109`	`});`
`110`	`110`
Original file line number	Diff line number	Diff line change
`@@ -236,7 +236,7 @@ impl Transaction {`
`236`	`236`	`(`
`237`	`237`	`self_.check_is_transaction_ready(),`
`238`	`238`	`exception.is_none(gil),`
`239`		`- PyErr::from_value_bound(exception.into_bound(gil)),`
	`239`	`+ PyErr::from_value(exception.into_bound(gil)),`
`240`	`240`	`self_.db_client.clone(),`
`241`	`241`	`)`
`242`	`242`	`});`