Merge pull request #55 from qaspen-python/feature/add_predefined_row_factories

Added predefined row factories

Author: chandr-andr

python/psqlpy/_internal/row_factories.pyi

@@ -0,0 +1,67 @@
+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.
+
+    ### Example:
+    ```python
+    from psqlpy.row_factories import class_row
+
+
+    class ValidationModel:
+        name: str
+        views_count: int
+
+
+    async def main:
+        res = await db_pool.execute(
+            "SELECT * FROM users",
+        )
+
+        results: list[ValidationModel] = res.row_factory(
+            class_row(ValidationModel),
+        )
+    ```
+    """
+
+    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",
+]

python/tests/test_row_factories.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, Type
+
+import pytest
+
+from psqlpy import ConnectionPool
+from psqlpy.row_factories import class_row, tuple_row
+
+pytestmark = pytest.mark.anyio
+
+
+async def test_tuple_row(
+    psql_pool: ConnectionPool,
+    table_name: str,
+    number_database_records: int,
+) -> None:
+    conn_result = await psql_pool.execute(
+        querystring=f"SELECT * FROM {table_name}",
+    )
+    tuple_res = conn_result.row_factory(row_factory=tuple_row)
+
+    assert len(tuple_res) == number_database_records
+    assert isinstance(tuple_res[0], tuple)
+
+
+async def test_class_row(
+    psql_pool: ConnectionPool,
+    table_name: str,
+    number_database_records: int,
+) -> None:
+    @dataclass
+    class ValidationTestModel:
+        id: int
+        name: str
+
+    conn_result = await psql_pool.execute(
+        querystring=f"SELECT * FROM {table_name}",
+    )
+    class_res = conn_result.row_factory(row_factory=class_row(ValidationTestModel))
+    assert len(class_res) == number_database_records
+    assert isinstance(class_res[0], ValidationTestModel)
+
+
+async def test_custom_row_factory(
+    psql_pool: ConnectionPool,
+    table_name: str,
+    number_database_records: int,
+) -> None:
+    @dataclass
+    class ValidationTestModel:
+        id: int
+        name: str
+
+    def to_class(
+        class_: Type[ValidationTestModel],
+    ) -> Callable[[Dict[str, Any]], ValidationTestModel]:
+        def to_class_inner(row: Dict[str, Any]) -> ValidationTestModel:
+            return class_(**row)
+
+        return to_class_inner
+
+    conn_result = await psql_pool.execute(
+        querystring=f"SELECT * FROM {table_name}",
+    )
+    class_res = conn_result.row_factory(row_factory=to_class(ValidationTestModel))
+
+    assert len(class_res) == number_database_records
+    assert isinstance(class_res[0], ValidationTestModel)

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(())
+}