Rewrite all exceptions to more readable ones

python/psqlpy/_internal/exceptions.pyi

@@ -13,9 +13,6 @@ class ConnectionPoolConfigurationError(BaseConnectionPoolError):
 class ConnectionPoolExecuteError(BaseConnectionPoolError):
     """Error in connection pool execution."""
 
-class DBPoolConfigurationError(RustPSQLDriverPyBaseError):
-    """Error if configuration of the database pool is unacceptable."""
-
 class BaseConnectionError(RustPSQLDriverPyBaseError):
     """Base error for Connection errors."""
 
@@ -55,8 +52,8 @@ class CursorFetchError(BaseCursorError):
 class UUIDValueConvertError(RustPSQLDriverPyBaseError):
     """Error if it's impossible to convert py string UUID into rust UUID."""
 
-class MacAddr6ConversionError(RustPSQLDriverPyBaseError):
-    """Error if cannot convert MacAddr6 string value to rust type."""
+class MacAddrConversionError(RustPSQLDriverPyBaseError):
+    """Error if cannot convert MacAddr string value to rust type."""
 
 class RustToPyValueMappingError(RustPSQLDriverPyBaseError):
     """Error if it is not possible to covert rust type to python.

python/psqlpy/exceptions.py

@@ -10,8 +10,7 @@
     CursorCloseError,
     CursorFetchError,
     CursorStartError,
-    DBPoolConfigurationError,
-    MacAddr6ConversionError,
+    MacAddrConversionError,
     PyToRustValueMappingError,
     RustPSQLDriverPyBaseError,
     RustToPyValueMappingError,
@@ -43,7 +42,6 @@
     "RustPSQLDriverPyBaseError",
     "RustToPyValueMappingError",
     "PyToRustValueMappingError",
-    "DBPoolConfigurationError",
     "UUIDValueConvertError",
-    "MacAddr6ConversionError",
+    "MacAddrConversionError",
 ]

python/tests/test_connection_pool.py

@@ -9,7 +9,10 @@
     TargetSessionAttrs,
     connect,
 )
-from psqlpy.exceptions import DBPoolConfigurationError, RustPSQLDriverPyBaseError
+from psqlpy.exceptions import (
+    ConnectionPoolConfigurationError,
+    RustPSQLDriverPyBaseError,
+)
 
 pytestmark = pytest.mark.anyio
 
@@ -94,22 +97,22 @@ async def test_pool_conn_recycling_method(
 
 
 async def test_build_pool_failure() -> None:
-    with pytest.raises(expected_exception=DBPoolConfigurationError):
+    with pytest.raises(expected_exception=ConnectionPoolConfigurationError):
         ConnectionPool(
             dsn="postgres://postgres:postgres@localhost:5432/psqlpy_test",
             connect_timeout_nanosec=12,
         )
-    with pytest.raises(expected_exception=DBPoolConfigurationError):
+    with pytest.raises(expected_exception=ConnectionPoolConfigurationError):
         ConnectionPool(
             dsn="postgres://postgres:postgres@localhost:5432/psqlpy_test",
             connect_timeout_nanosec=12,
         )
-    with pytest.raises(expected_exception=DBPoolConfigurationError):
+    with pytest.raises(expected_exception=ConnectionPoolConfigurationError):
         ConnectionPool(
             dsn="postgres://postgres:postgres@localhost:5432/psqlpy_test",
             keepalives_idle_nanosec=12,
         )
-    with pytest.raises(expected_exception=DBPoolConfigurationError):
+    with pytest.raises(expected_exception=ConnectionPoolConfigurationError):
         ConnectionPool(
             dsn="postgres://postgres:postgres@localhost:5432/psqlpy_test",
             keepalives_interval_nanosec=12,

src/exceptions/python_errors.rs

@@ -105,11 +105,6 @@ create_exception!(
     PyToRustValueMappingError,
     RustPSQLDriverPyBaseError
 );
-create_exception!(
-    psqlpy.exceptions,
-    DBPoolConfigurationError,
-    RustPSQLDriverPyBaseError
-);
 
 create_exception!(
     psqlpy.exceptions,
@@ -123,12 +118,6 @@ create_exception!(
     RustPSQLDriverPyBaseError
 );
 
-create_exception!(
-    psqlpy.exceptions,
-    RustRuntimeJoinError,
-    RustPSQLDriverPyBaseError
-);
-
 #[allow(clippy::missing_errors_doc)]
 pub fn python_exceptions_module(py: Python<'_>, pymod: &Bound<'_, PyModule>) -> PyResult<()> {
     pymod.add(
@@ -200,20 +189,12 @@ pub fn python_exceptions_module(py: Python<'_>, pymod: &Bound<'_, PyModule>) ->
         "PyToRustValueMappingError",
         py.get_type_bound::<PyToRustValueMappingError>(),
     )?;
-    pymod.add(
-        "DBPoolConfigurationError",
-        py.get_type_bound::<DBPoolConfigurationError>(),
-    )?;
     pymod.add(
         "UUIDValueConvertError",
         py.get_type_bound::<UUIDValueConvertError>(),
     )?;
     pymod.add(
-        "MacAddr6ConversionError",
-        py.get_type_bound::<MacAddrConversionError>(),
-    )?;
-    pymod.add(
-        "RustRuntimeJoinError",
+        "MacAddrConversionError",
         py.get_type_bound::<MacAddrConversionError>(),
     )?;
     Ok(())

src/exceptions/rust_errors.rs

@@ -1,16 +1,15 @@
 use thiserror::Error;
 use tokio::task::JoinError;
 
-use crate::exceptions::python_errors::{
-    DBPoolConfigurationError, PyToRustValueMappingError, RustToPyValueMappingError,
-};
+use crate::exceptions::python_errors::{PyToRustValueMappingError, RustToPyValueMappingError};
 
 use super::python_errors::{
     BaseConnectionError, BaseConnectionPoolError, BaseCursorError, BaseTransactionError,
-    ConnectionExecuteError, ConnectionPoolBuildError, ConnectionPoolExecuteError, CursorCloseError,
-    CursorFetchError, CursorStartError, DriverError, MacAddrParseError, RuntimeJoinError,
-    TransactionBeginError, TransactionCommitError, TransactionExecuteError,
-    TransactionRollbackError, TransactionSavepointError, UUIDValueConvertError,
+    ConnectionExecuteError, ConnectionPoolBuildError, ConnectionPoolConfigurationError,
+    ConnectionPoolExecuteError, CursorCloseError, CursorFetchError, CursorStartError, DriverError,
+    MacAddrParseError, RuntimeJoinError, TransactionBeginError, TransactionCommitError,
+    TransactionExecuteError, TransactionRollbackError, TransactionSavepointError,
+    UUIDValueConvertError,
 };
 
 pub type RustPSQLDriverPyResult<T> = Result<T, RustPSQLDriverError>;
@@ -97,7 +96,7 @@ impl From<RustPSQLDriverError> for pyo3::PyErr {
                 PyToRustValueMappingError::new_err((error_desc,))
             }
             RustPSQLDriverError::ConnectionPoolConfigurationError(_) => {
-                DBPoolConfigurationError::new_err((error_desc,))
+                ConnectionPoolConfigurationError::new_err((error_desc,))
             }
             RustPSQLDriverError::RustUUIDConvertError(_) => {
                 UUIDValueConvertError::new_err(error_desc)