Added build_point realization

Author: AGAEV Denis E

python/psqlpy/_internal/extra_types.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Sequence, Union
+import typing
 
 from typing_extensions import Self
 
@@ -73,9 +73,9 @@ class PyJSONB:
 
     def __init__(
         self: Self,
-        value: Union[
-            dict[str, Any],
-            list[dict[str, Any]],
+        value: typing.Union[
+            dict[str, typing.Any],
+            list[dict[str, typing.Any]],
         ],
     ) -> None:
         """Create new instance of PyJSON.B.
@@ -91,9 +91,9 @@ class PyJSON:
 
     def __init__(
         self: Self,
-        value: Union[
-            dict[str, Any],
-            list[dict[str, Any]],
+        value: typing.Union[
+            dict[str, typing.Any],
+            list[dict[str, typing.Any]],
         ],
     ) -> None:
         """Create new instance of PyJSON.
@@ -124,77 +124,87 @@ class PyMacAddr8:
         - `value`: value for MACADDR8 field.
         """
 
+Coordinates: typing.TypeAlias = typing.Union[
+    list[int | float],
+    set[int | float],
+    tuple[int | float],
+]
+
 class PyPoint:
     """Represent point field in PostgreSQL and Point in Rust."""
 
     def __init__(
         self: Self,
-        value: Sequence[float],
+        value: Coordinates,
     ) -> None:
         """Create new instance of PyPoint.
 
-        It accepts any sequence of two float numbers.
+        It accepts any pair(List, Tuple or Set)
+            of int/float numbers in every combination.
 
         ### Parameters:
-        - `value`: sequence of two float numbers.
+        - `value`: pair of int/float numbers in every combination.
         """
 
 class PyBox:
     """Represent box field in PostgreSQL and Rect in Rust."""
 
     def __init__(
         self: Self,
-        value: Union[
-            Sequence[Sequence[float]],
-            Sequence[float],
+        value: typing.Union[
+            typing.Union[list[Coordinates], set[Coordinates], tuple[Coordinates]],
+            Coordinates,
         ],
     ) -> None:
         """Create new instance of PyBox.
 
         You need to pass any of this structures:
-        - sequence of two sequences, each with pair of float numbers
-        - sequence of two pairs of float
+        - sequence of two sequences,
+            each with pair of int/float numbers in every combination
+        - sequence of two pairs of int/float in every combination
 
         ### Parameters:
-        - `value`: any valid sequence with two pairs of float numbers.
+        - `value`: any valid sequence with two pairs
+            of int/float numbers in every combination.
         """
 
 class PyPath:
     """Represent path field in PostgreSQL and LineString in Rust."""
 
     def __init__(
         self: Self,
-        value: Union[
-            Sequence[Sequence[float]],
-            Sequence[float],
+        value: typing.Union[
+            typing.Union[list[Coordinates], set[Coordinates], tuple[Coordinates]],
+            Coordinates,
         ],
     ) -> None:
         """Create new instance of PyPath.
 
         You need to pass any of this structures:
-        - sequence of sequences, each with pair of float numbers
-        - sequence with pairs of float numbers
+        - sequence of sequences, each with pair of int/float numbers in every combination
+        - sequence with pairs of int/float numbers in every combination
 
         ### Parameters:
-        - `value`: any valid structure with float numbers.
+        - `value`: any valid structure with int/float numbers in every combination.
         """
 
 class PyLine:
     """Represent line field in PostgreSQL and Line in Rust."""
 
     def __init__(
         self: Self,
-        value: Union[
-            Sequence[Sequence[float]],
-            Sequence[float],
+        value: typing.Union[
+            typing.Union[list[Coordinates], set[Coordinates], tuple[Coordinates]],
+            Coordinates,
         ],
     ) -> None:
         """Create new instance of PyLine.
 
         You need to pass any of this structures:
-        - sequence of three float numbers
-        - sequence of two sequences, each with pair of float numbers
-        - sequence with two pairs of float numbers
+        - sequence of three int/float numbers
+        - sequence of two sequences,
+            each with pair of int/float numbers in every combination
+        - sequence with two pairs of int/float numbers in every combination
 
         ### Parameters:
         - `value`: any valid structure with float numbers.
@@ -205,37 +215,38 @@ class PyLineSegment:
 
     def __init__(
         self: Self,
-        value: Union[
-            Sequence[Sequence[float]],
-            Sequence[float],
+        value: typing.Union[
+            typing.Union[list[Coordinates], set[Coordinates], tuple[Coordinates]],
+            Coordinates,
         ],
     ) -> None:
         """Create new instance of PyLineSegment.
 
         You need to pass any of this structures:
-        - sequence of two sequences, each with pair of float numbers
-        - sequence with two pairs of float numbers
+        - sequence of two sequences,
+            each with pair of int/float numbers in every combination
+        - sequence with two pairs of int/float numbers in every combination
 
         ### Parameters:
-        - `value`: any valid structure with float numbers.
+        - `value`: any valid structure with int/float numbers in every combination.
         """
 
 class PyPolygon:
     """Represent polygon field in PostgreSQL and Polygon in Rust."""
 
     def __init__(
         self: Self,
-        value: Union[
-            Sequence[Sequence[float]],
-            Sequence[float],
+        value: typing.Union[
+            typing.Union[list[Coordinates], set[Coordinates], tuple[Coordinates]],
+            Coordinates,
         ],
     ) -> None:
         """Create new instance of PyPolygon.
 
         You need to pass any of this structures:
-        - sequence of sequences, each with pair of float numbers
-        - sequence with pairs of float numbers
+        - sequence of sequences, each with pair of int/float numbers in every combination
+        - sequence with pairs of int/float numbers in every combination
 
         ### Parameters:
-        - `value`: any valid structure with float numbers.
+        - `value`: any valid structure with int/float numbers in every combination.
         """

src/additional_types.rs

@@ -1,7 +1,7 @@
+use byteorder::{BigEndian, ReadBytesExt};
+use geo_types::{coord, Coord, CoordFloat, CoordNum, Line, LineString, Polygon};
 use itertools::Itertools;
 use macaddr::{MacAddr6, MacAddr8};
-use geo_types::{coord, Coord, CoordFloat, CoordNum, Line, LineString, Polygon};
-use byteorder::{ReadBytesExt, BigEndian};
 use tokio_postgres::types::{FromSql, Type};
 
 macro_rules! build_additional_rust_type {
@@ -73,7 +73,7 @@ impl<'a> FromSql<'a> for RustLine {
         raw: &'a [u8],
     ) -> Result<RustLine, Box<dyn std::error::Error + Sync + Send>> {
         if raw.len() == 4 {
-            let mut vec_raw= vec![];
+            let mut vec_raw = vec![];
             vec_raw.extend_from_slice(raw);
             let mut buf = vec_raw.as_slice();
 
@@ -108,14 +108,14 @@ impl<'a> FromSql<'a> for RustPolygon {
 
             let mut vec_raw_coord = vec![];
             buf.read_f64_into::<BigEndian>(&mut vec_raw_coord);
-        
+
             let mut vec_coord = vec![];
             for (x1, y1) in vec_raw_coord.into_iter().tuples() {
                 vec_coord.push(coord!(x: x1, y: y1));
             }
 
             let polygon_exterior = LineString::new(vec_coord);
-            let new_polygon  = Polygon::new(polygon_exterior, vec![]);
+            let new_polygon = Polygon::new(polygon_exterior, vec![]);
             return Ok(RustPolygon::new(new_polygon));
         }
         Err("Cannot convert PostgreSQL POLYGON into rust Polygon".into())
@@ -126,7 +126,6 @@ impl<'a> FromSql<'a> for RustPolygon {
     }
 }
 
-
 // add macro for creating circles
 
 #[derive(Eq, PartialEq, Clone, Copy, Debug, Hash)]
@@ -138,7 +137,10 @@ pub struct Circle<T: CoordNum = f64> {
 
 impl<T: CoordNum> Circle<T> {
     pub fn new(x: T, y: T, r: T) -> Self {
-        Self {center: coord!(x: x, y: y), radius: r}
+        Self {
+            center: coord!(x: x, y: y),
+            radius: r,
+        }
     }
 
     pub fn center(self) -> Coord<T> {
@@ -186,7 +188,10 @@ 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()}
+        Self {
+            center: coord! {x: T::zero(), y: T::zero()},
+            radius: T::zero(),
+        }
     }
 }
 
@@ -213,4 +218,4 @@ impl<'a> FromSql<'a> for Circle {
     fn accepts(_ty: &Type) -> bool {
         true
     }
-}
+}

src/value_converter.rs

@@ -1,5 +1,5 @@
 use chrono::{self, DateTime, FixedOffset, NaiveDate, NaiveDateTime, NaiveTime};
-use geo_types::Point;
+use geo_types::{point, Point};
 use macaddr::{MacAddr6, MacAddr8};
 use postgres_types::{Field, FromSql, Kind};
 use serde_json::{json, Map, Value};
@@ -10,8 +10,8 @@ use bytes::{BufMut, BytesMut};
 use postgres_protocol::types;
 use pyo3::{
     types::{
-        PyAnyMethods, PyBool, PyBytes, PyDate, PyDateTime, PyDict, PyDictMethods,
-        PyFloat, PyInt, PyList, PyListMethods, PySet, PyString, PyTime, PyTuple
+        PyAnyMethods, PyBool, PyBytes, PyDate, PyDateTime, PyDict, PyDictMethods, PyFloat, PyInt,
+        PyList, PyListMethods, PySet, PyString, PyTime, PyTuple,
     },
     Bound, Py, PyAny, Python, ToPyObject,
 };
@@ -24,8 +24,8 @@ use crate::{
     additional_types::{RustMacAddr6, RustMacAddr8},
     exceptions::rust_errors::{RustPSQLDriverError, RustPSQLDriverPyResult},
     extra_types::{
-        BigInt, Integer, PyJSON, PyJSONB, PyMacAddr6, PyMacAddr8, PyText, PyUUID,
-        PyVarChar, SmallInt,
+        BigInt, Integer, PyJSON, PyJSONB, PyMacAddr6, PyMacAddr8, PyText, PyUUID, PyVarChar,
+        SmallInt,
     },
 };
 
@@ -851,7 +851,7 @@ pub fn build_python_from_serde_value(
     }
 }
 
-/// Convert python List or Tuple into geo `Point`.
+/// Convert python List, Tuple or Set into geo `Point`.
 ///
 /// # Errors
 /// May return error if cannot convert Python type into Rust one.
@@ -863,25 +863,58 @@ pub fn build_point(value: Py<PyAny>) -> RustPSQLDriverPyResult<Point> {
             | bind_value.is_instance_of::<PyTuple>()
             | bind_value.is_instance_of::<PySet>()
         {
-            let mut result_vec = vec![];
+            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(),
+                ));
+            }
+
             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)?;
-                    let mut bu = BytesMut::with_capacity(64);
-                    python_dto.to_sql(postgres_types::, &mut bu)
+                    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 {
                     return Err(RustPSQLDriverError::PyToRustValueConversionError(
-                        "PyJSON supports only list/tuple/set of two int or two float.".to_string(),
+                        "PyPoint supports only list/tuple/set pair of int/float combination."
+                            .to_string(),
                     ));
                 }
             }
-            Ok(point!(result_vec))
+
+            Ok(point!(x: result_vec[0], y: result_vec[1]))
         } else {
             return Err(RustPSQLDriverError::PyToRustValueConversionError(
-                "PyPoint must have two int or float values passed in tuple, list or set.".to_string(),
+                "PyPoint must have pair int/float values combination passed in tuple, list or set."
+                    .to_string(),
             ));
         }
     })