Add PyItem container

Also reduce queue item trait bound from Ord to just PartialOrd

src/backing/containers/mod.rs

@@ -1,3 +1,5 @@
 mod pair;
+mod py_item;
 
 pub use pair::Pair;
+pub use py_item::PyItem;

src/backing/containers/pair.rs

@@ -1,8 +1,7 @@
 use std::cmp::Ordering;
 
-/// Helper struct to associate an item with its priority
+/// Container to associate an item with a priority
 #[derive(Debug, Clone, Copy)]
-// I mean I guess P should be Ord but I want to use f64 so whatever
 pub struct Pair<D: Clone, P: PartialOrd + Clone> {
     data: D,
     priority: P,
@@ -14,23 +13,13 @@ impl<D: Clone, P: PartialOrd + Clone> Pair<D, P> {
         Self { data, priority }
     }
 
-    /// Retrieve the internal data, it would be nicer to implement this using [`From`] or [`Into`], but I don't see a way to do that using generics
+    /// Retrieves the internal data.
+    /// It would be nicer to implement this using [`From`] or [`Into`], but I don't see a way to do that using generics.
     pub fn data(self) -> D {
         self.data
     }
 }
 
-// The relevant Ord implementations are based just on the priority
-impl<D: Clone, P: PartialOrd + Clone> Ord for Pair<D, P> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        // Yeah this is bad design
-        // My excuse is that i'm still learning Rust
-        self.priority
-            .partial_cmp(&other.priority)
-            .unwrap_or(Ordering::Equal)
-    }
-}
-
 impl<D: Clone, P: PartialOrd + Clone> PartialOrd for Pair<D, P> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         self.priority.partial_cmp(&other.priority)
@@ -42,5 +31,3 @@ impl<D: Clone, P: PartialOrd + Clone> PartialEq for Pair<D, P> {
         self.priority == other.priority
     }
 }
-
-impl<D: Clone, P: PartialOrd + Clone> Eq for Pair<D, P> {}

src/backing/containers/py_item.rs

@@ -0,0 +1,46 @@
+use std::cmp::Ordering;
+
+use pyo3::prelude::*;
+
+/// Container that provides PartialOrd based on the Python object it holds
+#[derive(Debug, Clone)]
+pub struct PyItem(Py<PyAny>);
+
+impl PyItem {
+    /// Creates a new instance
+    fn new(item: Py<PyAny>) -> Self {
+        PyItem(item)
+    }
+
+    /// Retrieves the internal data
+    fn item(self) -> Py<PyAny> {
+        self.0
+    }
+}
+
+impl PartialOrd for PyItem {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Python::with_gil(|py| {
+            // Bind objects for convenience
+            let ours = self.0.bind(py);
+            let theirs = other.0.bind(py);
+
+            // Compare based on Python comparison implementations
+            match ours.lt(theirs) {
+                Ok(true) => Some(Ordering::Less),
+                Ok(false) => match ours.gt(theirs) {
+                    Ok(true) => Some(Ordering::Greater),
+                    Ok(false) => Some(Ordering::Equal), // If the python class is implemented strangely then this may be wrong
+                    Err(_) => None,
+                },
+                Err(_) => None,
+            }
+        })
+    }
+}
+
+impl PartialEq for PyItem {
+    fn eq(&self, other: &Self) -> bool {
+        Python::with_gil(|py| self.0.bind(py).eq(other.0.bind(py)).unwrap_or(false))
+    }
+}