Started implementing new realization. pre-commit disabled.

Signed-off-by: chandr-andr (Kiselev Aleksandr) <chandr@chandr.net>

Author: chandr-andr

Cargo.lock

@@ -10,15 +10,14 @@ crate-type = ["cdylib"]
 
 [dependencies]
 deadpool-postgres = "0.12.1"
-pyo3 = { version = "0.19.2", features = ["chrono"] }
+pyo3 = { version = "*", features = ["chrono", "experimental-async"] }
 tokio = { version = "1.35.1", features = ["full"] }
 tokio-postgres = { version = "0.7.10", features = [
     "with-serde_json-1",
     "array-impls",
     "with-chrono-0_4",
     "with-uuid-1",
 ] }
-pyo3-asyncio = { version = "0.19.0", features = ["tokio-runtime"] }
 thiserror = "1.0.56"
 bytes = "1.5.0"
 byteorder = "1.5.0"

Cargo.toml

@@ -1,21 +1,23 @@
 from ._internal import (
-    Connection,
-    ConnRecyclingMethod,
-    Cursor,
-    IsolationLevel,
-    PSQLPool,
-    QueryResult,
-    ReadVariant,
-    Transaction,
+    # Connection,
+    # ConnRecyclingMethod,
+    # Cursor,
+    # IsolationLevel,
+    # PSQLPool,
+    # QueryResult,
+    # ReadVariant,
+    # Transaction,
+    ConnectionPool,
 )
 
 __all__ = [
-    "PSQLPool",
-    "QueryResult",
-    "Transaction",
-    "IsolationLevel",
-    "ReadVariant",
-    "Connection",
-    "Cursor",
-    "ConnRecyclingMethod",
+    "ConnectionPool",
+    # "PSQLPool",
+    # "QueryResult",
+    # "Transaction",
+    # "IsolationLevel",
+    # "ReadVariant",
+    # "Connection",
+    # "Cursor",
+    # "ConnRecyclingMethod",
 ]

python/psqlpy/__init__.py

@@ -940,3 +940,80 @@ class PSQLPool:
 
         It acquires new connection from the database pool.
         """
+
+
+class ConnectionPool:
+    """Connection pool for executing queries.
+
+    This is the main entrypoint in the library.
+    """
+
+    def __init__(
+        self: Self,
+        dsn: Optional[str] = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        db_name: Optional[str] = None,
+        max_db_pool_size: int = 2,
+        conn_recycling_method: Optional[ConnRecyclingMethod] = None,
+    ) -> None:
+        """Create new PostgreSQL connection pool.
+
+        It connects to the database and create pool.
+
+        You cannot set the minimum size for the connection
+        pool, by default it is 1.
+
+        This connection pool can:
+        - Startup itself with `startup` method
+        - Execute queries and return `QueryResult` class as a result
+        - Create new instance of `Transaction`
+
+        ### Parameters:
+        - `dsn`: full dsn connection string.
+            `postgres://postgres:postgres@localhost:5432/postgres?target_session_attrs=read-write`
+        - `username`: username of the user in postgres
+        - `password`: password of the user in postgres
+        - `host`: host of postgres
+        - `port`: port of postgres
+        - `db_name`: name of the database in postgres
+        - `max_db_pool_size`: maximum size of the connection pool
+        - `conn_recycling_method`: how a connection is recycled.
+        """
+    async def execute(
+        self: Self,
+        querystring: str,
+        parameters: list[Any] | None = None,
+        prepared: bool = True,
+    ) -> QueryResult:
+        """Execute the query.
+
+        Querystring can contain `$<number>` parameters
+        for converting them in the driver side.
+
+        ### Parameters:
+        - `querystring`: querystring to execute.
+        - `parameters`: list of parameters to pass in the query.
+        - `prepared`: should the querystring be prepared before the request.
+            By default any querystring will be prepared.
+
+        ### Example:
+        ```python
+        import asyncio
+
+        from psqlpy import PSQLPool, QueryResult
+
+
+        async def main() -> None:
+            db_pool = PSQLPool()
+            query_result: QueryResult = await psqlpy.execute(
+                "SELECT username FROM users WHERE id = $1",
+                [100],
+            )
+            dict_result: List[Dict[Any, Any]] = query_result.result()
+            # you don't need to close the pool,
+            # it will be dropped on Rust side.
+        ```
+        """

python/psqlpy/_internal/__init__.pyi

@@ -28,19 +28,19 @@ pub fn add_module(
     Ok(())
 }
 
-/// Simple wrapper for pyo3 `pyo3_asyncio::tokio::future_into_py`.
-///
-/// It wraps incoming Future and return internal Result.
-///
-/// # Errors
-///
-/// May return Err Result if future acts incorrect.
-pub fn rustdriver_future<F, T>(py: Python<'_>, future: F) -> RustPSQLDriverPyResult<&PyAny>
-where
-    F: Future<Output = RustPSQLDriverPyResult<T>> + Send + 'static,
-    T: IntoPy<PyObject>,
-{
-    let res = pyo3_asyncio::tokio::future_into_py(py, async { future.await.map_err(Into::into) })
-        .map(Into::into)?;
-    Ok(res)
-}
+// /// Simple wrapper for pyo3 `pyo3_asyncio::tokio::future_into_py`.
+// ///
+// /// It wraps incoming Future and return internal Result.
+// ///
+// /// # Errors
+// ///
+// /// May return Err Result if future acts incorrect.
+// pub fn rustdriver_future<F, T>(py: Python<'_>, future: F) -> RustPSQLDriverPyResult<&PyAny>
+// where
+//     F: Future<Output = RustPSQLDriverPyResult<T>> + Send + 'static,
+//     T: IntoPy<PyObject>,
+// {
+//     let res = pyo3_asyncio::tokio::future_into_py(py, async { future.await.map_err(Into::into) })
+//         .map(Into::into)?;
+//     Ok(res)
+// }