Fix errors

Author: AGAEV Denis E

python/psqlpy/_internal/__init__.pyi

@@ -16,6 +16,7 @@ class QueryResult:
         custom_decoders: dict[str, Callable[[bytes], Any]] | None = None,
     ) -> list[dict[Any, Any]]:
         """Return result from database as a list of dicts."""
+
     def as_class(
         self: Self,
         as_class: Callable[..., _CustomClass],
@@ -57,6 +58,7 @@ class SingleQueryResult:
 
     def result(self: Self) -> dict[Any, Any]:
         """Return result from database as a dict."""
+
     def as_class(
         self: Self,
         as_class: Callable[..., _CustomClass],
@@ -191,11 +193,13 @@ class Cursor:
 
         Execute DECLARE command for the cursor.
         """
+
     async def close(self: Self) -> None:
         """Close the cursor.
 
         Execute CLOSE command for the cursor.
         """
+
     async def fetch(
         self: Self,
         fetch_number: int | None = None,
@@ -210,6 +214,7 @@ class Cursor:
         ### Returns:
         result as `QueryResult`.
         """
+
     async def fetch_next(
         self: Self,
     ) -> QueryResult:
@@ -220,6 +225,7 @@ class Cursor:
         ### Returns:
         result as `QueryResult`.
         """
+
     async def fetch_prior(
         self: Self,
     ) -> QueryResult:
@@ -230,6 +236,7 @@ class Cursor:
         ### Returns:
         result as `QueryResult`.
         """
+
     async def fetch_first(
         self: Self,
     ) -> QueryResult:
@@ -240,6 +247,7 @@ class Cursor:
         ### Returns:
         result as `QueryResult`.
         """
+
     async def fetch_last(
         self: Self,
     ) -> QueryResult:
@@ -250,6 +258,7 @@ class Cursor:
         ### Returns:
         result as `QueryResult`.
         """
+
     async def fetch_absolute(
         self: Self,
         absolute_number: int,
@@ -261,6 +270,7 @@ class Cursor:
         ### Returns:
         result as `QueryResult`.
         """
+
     async def fetch_relative(
         self: Self,
         relative_number: int,
@@ -272,6 +282,7 @@ class Cursor:
         ### Returns:
         result as `QueryResult`.
         """
+
     async def fetch_forward_all(
         self: Self,
     ) -> QueryResult:
@@ -282,6 +293,7 @@ class Cursor:
         ### Returns:
         result as `QueryResult`.
         """
+
     async def fetch_backward(
         self: Self,
         backward_count: int,
@@ -293,6 +305,7 @@ class Cursor:
         ### Returns:
         result as `QueryResult`.
         """
+
     async def fetch_backward_all(
         self: Self,
     ) -> QueryResult:
@@ -327,13 +340,15 @@ class Transaction:
 
         `begin()` can be called only once per transaction.
         """
+
     async def commit(self: Self) -> None:
         """Commit the transaction.
 
         Execute `COMMIT`.
 
         `commit()` can be called only once per transaction.
         """
+
     async def execute(
         self: Self,
         querystring: str,
@@ -372,6 +387,7 @@ class Transaction:
             await transaction.commit()
         ```
         """
+
     async def execute_many(
         self: Self,
         querystring: str,
@@ -430,6 +446,7 @@ class Transaction:
         - `prepared`: should the querystring be prepared before the request.
             By default any querystring will be prepared.
         """
+
     async def fetch_row(
         self: Self,
         querystring: str,
@@ -470,6 +487,7 @@ class Transaction:
             await transaction.commit()
         ```
         """
+
     async def fetch_val(
         self: Self,
         querystring: str,
@@ -511,6 +529,7 @@ class Transaction:
             )
         ```
         """
+
     async def pipeline(
         self,
         queries: list[tuple[str, list[Any] | None]],
@@ -577,6 +596,7 @@ class Transaction:
 
         ```
         """
+
     async def create_savepoint(self: Self, savepoint_name: str) -> None:
         """Create new savepoint.
 
@@ -606,6 +626,7 @@ class Transaction:
             await transaction.rollback_savepoint("my_savepoint")
         ```
         """
+
     async def rollback(self: Self) -> None:
         """Rollback all queries in the transaction.
 
@@ -627,6 +648,7 @@ class Transaction:
             await transaction.rollback()
         ```
         """
+
     async def rollback_savepoint(self: Self, savepoint_name: str) -> None:
         """ROLLBACK to the specified `savepoint_name`.
 
@@ -653,6 +675,7 @@ class Transaction:
             await transaction.rollback_savepoint("my_savepoint")
         ```
         """
+
     async def release_savepoint(self: Self, savepoint_name: str) -> None:
         """Execute ROLLBACK TO SAVEPOINT.
 
@@ -678,6 +701,7 @@ class Transaction:
             await transaction.release_savepoint
         ```
         """
+
     def cursor(
         self: Self,
         querystring: str,
@@ -771,6 +795,7 @@ class Connection:
             dict_result: List[Dict[Any, Any]] = query_result.result()
         ```
         """
+
     async def execute_many(
         self: Self,
         querystring: str,
@@ -824,6 +849,7 @@ class Connection:
         - `prepared`: should the querystring be prepared before the request.
             By default any querystring will be prepared.
         """
+
     async def fetch_row(
         self: Self,
         querystring: str,
@@ -861,6 +887,7 @@ class Connection:
             dict_result: Dict[Any, Any] = query_result.result()
         ```
         """
+
     async def fetch_val(
         self: Self,
         querystring: str,
@@ -901,6 +928,7 @@ class Connection:
             )
         ```
         """
+
     def transaction(
         self,
         isolation_level: IsolationLevel | None = None,
@@ -1016,6 +1044,7 @@ class ConnectionPool:
         - `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,
@@ -1051,6 +1080,7 @@ class ConnectionPool:
             # it will be dropped on Rust side.
         ```
         """
+
     async def fetch(
         self: Self,
         querystring: str,
@@ -1071,11 +1101,13 @@ class ConnectionPool:
         - `prepared`: should the querystring be prepared before the request.
             By default any querystring will be prepared.
         """
+
     async def connection(self: Self) -> Connection:
         """Create new connection.
 
         It acquires new connection from the database pool.
         """
+
     def close(self: Self) -> None:
         """Close the connection pool."""
 

src/additional_types.rs

@@ -89,7 +89,7 @@ impl<'a> FromSql<'a> for RustLine {
         let second_coord = coord!(x: x2, y: y2);
 
         let new_line = Line::new(first_coord, second_coord);
-        return Ok(RustLine::new(new_line));
+        Ok(RustLine::new(new_line))
     }
 
     fn accepts(_ty: &Type) -> bool {
@@ -120,7 +120,7 @@ impl<'a> FromSql<'a> for RustPolygon {
 
         let polygon_exterior = LineString::new(vec_coord);
         let new_polygon = Polygon::new(polygon_exterior, vec![]);
-        return Ok(RustPolygon::new(new_polygon));
+        Ok(RustPolygon::new(new_polygon))
     }
 
     fn accepts(_ty: &Type) -> bool {
@@ -188,15 +188,6 @@ impl<T: CoordFloat> Circle<T> {
     }
 }
 
-impl<T: CoordNum> Default for Circle<T> {
-    fn default() -> Self {
-        Self {
-            center: coord! {x: T::zero(), y: T::zero()},
-            radius: T::zero(),
-        }
-    }
-}
-
 impl<'a> FromSql<'a> for Circle {
     fn from_sql(
         _ty: &Type,
@@ -215,7 +206,7 @@ impl<'a> FromSql<'a> for Circle {
         let r = buf.read_f64::<BigEndian>()?;
 
         let new_circle = Circle::new(x, y, r);
-        return Ok(new_circle);
+        Ok(new_circle)
     }
 
     fn accepts(_ty: &Type) -> bool {

src/value_converter.rs

@@ -850,63 +850,54 @@ pub fn build_python_from_serde_value(
 pub fn build_point(value: Py<PyAny>) -> RustPSQLDriverPyResult<Point> {
     Python::with_gil(|gil| {
         let bind_value = value.bind(gil);
-        if bind_value.is_instance_of::<PyList>()
-            | bind_value.is_instance_of::<PyTuple>()
-            | bind_value.is_instance_of::<PySet>()
+        if !bind_value.is_instance_of::<PyList>()
+            & !bind_value.is_instance_of::<PyTuple>()
+            & !bind_value.is_instance_of::<PySet>()
         {
-            let mut result_vec: Vec<f64> = vec![];
-            let params = bind_value.extract::<Vec<Py<PyAny>>>()?;
+            return Err(RustPSQLDriverError::PyToRustValueConversionError(
+                "PyPoint must have pair int/float values combination passed in tuple, list or set."
+                    .to_string(),
+            ));
+        }
+
+        let mut result_vec: Vec<f64> = vec![];
+        let params = bind_value.extract::<Vec<Py<PyAny>>>()?;
+
+        if params.len() != 2 {
+            return Err(RustPSQLDriverError::PyToRustValueConversionError(
+                "PyPoint supports only pair of int/float combination.".to_string(),
+            ));
+        }
 
-            if params.len() != 2 {
+        for inner in params {
+            let inner_bind = inner.bind(gil);
+
+            if !inner_bind.is_instance_of::<PyFloat>() & !inner_bind.is_instance_of::<PyInt>() {
                 return Err(RustPSQLDriverError::PyToRustValueConversionError(
-                    "PyPoint supports only pair of int/float combination.".to_string(),
+                    "PyPoint supports only list/tuple/set pair of int/float combination."
+                        .to_string(),
                 ));
             }
 
-            for inner in params {
-                let inner_bind = inner.bind(gil);
-
-                if inner_bind.is_instance_of::<PyFloat>() | inner_bind.is_instance_of::<PyInt>() {
-                    let python_dto = py_to_rust(inner_bind)?;
-                    match python_dto {
-                        PythonDTO::PyIntI16(pyint) => result_vec.push(pyint.try_into().unwrap()),
-                        PythonDTO::PyIntI32(pyint) => result_vec.push(pyint.try_into().unwrap()),
-                        PythonDTO::PyIntI64(_) => {
-                            return Err(RustPSQLDriverError::PyToRustValueConversionError(
-                                "Not implemented this type yet".into(),
-                            ))
-                        }
-                        PythonDTO::PyIntU32(pyint) => result_vec.push(pyint.try_into().unwrap()),
-                        PythonDTO::PyIntU64(_) => {
-                            return Err(RustPSQLDriverError::PyToRustValueConversionError(
-                                "Not implemented this type yet".into(),
-                            ))
-                        }
-                        PythonDTO::PyFloat32(pyfloat) => {
-                            result_vec.push(pyfloat.try_into().unwrap())
-                        }
-                        PythonDTO::PyFloat64(pyfloat) => result_vec.push(pyfloat),
-                        _ => {
-                            return Err(RustPSQLDriverError::PyToRustValueConversionError(
-                                "Incorrect types of point coordinates. It must be int or float"
-                                    .into(),
-                            ))
-                        }
-                    };
-                } else {
+            let python_dto = py_to_rust(inner_bind)?;
+            match python_dto {
+                PythonDTO::PyIntI16(pyint) => result_vec.push(pyint.into()),
+                PythonDTO::PyIntI32(pyint) => result_vec.push(pyint.into()),
+                PythonDTO::PyIntU32(pyint) => result_vec.push(pyint.into()),
+                PythonDTO::PyFloat32(pyfloat) => result_vec.push(pyfloat.into()),
+                PythonDTO::PyFloat64(pyfloat) => result_vec.push(pyfloat),
+                PythonDTO::PyIntI64(_) | PythonDTO::PyIntU64(_) => {
                     return Err(RustPSQLDriverError::PyToRustValueConversionError(
-                        "PyPoint supports only list/tuple/set pair of int/float combination."
-                            .to_string(),
-                    ));
+                        "Not implemented this type yet".into(),
+                    ))
                 }
-            }
-
-            return Ok(point!(x: result_vec[0], y: result_vec[1]));
+                _ => {
+                    return Err(RustPSQLDriverError::PyToRustValueConversionError(
+                        "Incorrect types of point coordinates. It must be int or float".into(),
+                    ))
+                }
+            };
         }
-
-        return Err(RustPSQLDriverError::PyToRustValueConversionError(
-            "PyPoint must have pair int/float values combination passed in tuple, list or set."
-                .to_string(),
-        ));
+        Ok(point!(x: result_vec[0], y: result_vec[1]))
     })
 }