Added predefined row factories

Signed-off-by: chandr-andr (Kiselev Aleksandr) <[email protected]>

Author: chandr-andr

python/psqlpy/_internal/row_factories.pyi

@@ -0,0 +1,46 @@
+from typing import Any, Generic, Tuple, Type, TypeVar
+
+from typing_extensions import Self
+
+_CustomClass = TypeVar(
+    "_CustomClass",
+)
+
+def tuple_row(row: dict[str, Any]) -> Tuple[Tuple[str, Any]]:
+    """Convert dict row into tuple row.
+
+    ### Parameters:
+    - `row`: row in dictionary.
+
+    ### Returns:
+    row as a tuple of tuples.
+
+    ### Example:
+    ```
+    dict_ = {
+        "psqlpy": "is",
+        "postgresql": "driver",
+    }
+    # This function will convert this dict into:
+    (("psqlpy", "is"), ("postgresql": "driver"))
+    ```
+    """
+
+class class_row(Generic[_CustomClass]):  # noqa: N801
+    """Row converter to specified class."""
+
+    def __init__(self: Self, class_: Type[_CustomClass]) -> None:
+        """Construct new `class_row`.
+
+        ### Parameters:
+        - `class_`: class to transform row into.
+        """
+    def __call__(self, row: dict[str, Any]) -> _CustomClass:
+        """Convert row into specified class.
+
+        ### Parameters:
+        - `row`: row in dictionary.
+
+        ### Returns:
+        Constructed specified class.
+        """

python/psqlpy/row_factories.py

@@ -0,0 +1,6 @@
+from ._internal.row_factories import class_row, tuple_row
+
+__all__ = [
+    "tuple_row",
+    "class_row",
+]

src/lib.rs

@@ -4,13 +4,15 @@ pub mod driver;
 pub mod exceptions;
 pub mod extra_types;
 pub mod query_result;
+pub mod row_factories;
 pub mod runtime;
 pub mod value_converter;
 
 use common::add_module;
 use exceptions::python_errors::python_exceptions_module;
 use extra_types::extra_types_module;
 use pyo3::{pymodule, types::PyModule, wrap_pyfunction, Bound, PyResult, Python};
+use row_factories::row_factories_module;
 
 #[pymodule]
 #[pyo3(name = "_internal")]
@@ -32,5 +34,6 @@ fn psqlpy(py: Python<'_>, pymod: &Bound<'_, PyModule>) -> PyResult<()> {
     pymod.add_class::<query_result::PSQLDriverSinglePyQueryResult>()?;
     add_module(py, pymod, "extra_types", extra_types_module)?;
     add_module(py, pymod, "exceptions", python_exceptions_module)?;
+    add_module(py, pymod, "row_factories", row_factories_module)?;
     Ok(())
 }

src/row_factories.rs

@@ -0,0 +1,48 @@
+use pyo3::{
+    pyclass, pyfunction, pymethods,
+    types::{PyDict, PyDictMethods, PyModule, PyModuleMethods, PyTuple},
+    wrap_pyfunction, Bound, Py, PyAny, PyResult, Python, ToPyObject,
+};
+
+use crate::exceptions::rust_errors::{RustPSQLDriverError, RustPSQLDriverPyResult};
+
+#[pyfunction]
+#[allow(clippy::needless_pass_by_value)]
+fn tuple_row(py: Python<'_>, dict_: Py<PyAny>) -> RustPSQLDriverPyResult<Py<PyAny>> {
+    let dict_ = dict_.downcast_bound::<PyDict>(py).map_err(|_| {
+        RustPSQLDriverError::RustToPyValueConversionError(
+            "as_tuple accepts only dict as a parameter".into(),
+        )
+    })?;
+    Ok(PyTuple::new_bound(py, dict_.items()).to_object(py))
+}
+
+#[pyclass]
+#[allow(non_camel_case_types)]
+struct class_row(Py<PyAny>);
+
+#[pymethods]
+impl class_row {
+    #[new]
+    fn constract_class(class_: Py<PyAny>) -> Self {
+        Self(class_)
+    }
+
+    #[allow(clippy::needless_pass_by_value)]
+    fn __call__(&self, py: Python<'_>, dict_: Py<PyAny>) -> RustPSQLDriverPyResult<Py<PyAny>> {
+        let dict_ = dict_.downcast_bound::<PyDict>(py).map_err(|_| {
+            RustPSQLDriverError::RustToPyValueConversionError(
+                "as_tuple accepts only dict as a parameter".into(),
+            )
+        })?;
+        Ok(self.0.call_bound(py, (), Some(dict_))?)
+    }
+}
+
+#[allow(clippy::module_name_repetitions)]
+#[allow(clippy::missing_errors_doc)]
+pub fn row_factories_module(_py: Python<'_>, pymod: &Bound<'_, PyModule>) -> PyResult<()> {
+    pymod.add_function(wrap_pyfunction!(tuple_row, pymod)?)?;
+    pymod.add_class::<class_row>()?;
+    Ok(())
+}