rust-discovery: exposing sampling to python

Differential Revision: https://phab.mercurial-scm.org/D6425

rust/hg-cpython/src/discovery.rs

@@ -1,135 +1,161 b''
 // discovery.rs
 //
 // Copyright 2018 Georges Racinet <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 //! Bindings for the `hg::discovery` module provided by the
 //! `hg-core` crate. From Python, this will be seen as `rustext.discovery`
 //!
 //! # Classes visible from Python:
 //! - [`PartialDiscover`] is the Rust implementation of
 //!   `mercurial.setdiscovery.partialdiscovery`.
 
 use crate::{
     cindex::Index,
     conversion::{py_set, rev_pyiter_collect},
     exceptions::GraphError,
 };
 use cpython::{
-    ObjectProtocol, PyDict, PyModule, PyObject, PyResult, Python,
+    ObjectProtocol, PyDict, PyModule, PyObject, PyResult, PyTuple, Python,
     PythonObject, ToPyObject,
 };
 use hg::discovery::PartialDiscovery as CorePartialDiscovery;
 use hg::Revision;
 
 use std::cell::RefCell;
 
 py_class!(pub class PartialDiscovery |py| {
     data inner: RefCell<Box<CorePartialDiscovery<Index>>>;
 
     // `_respectsize` is currently only here to replicate the Python API and
     // will be used in future patches inside methods that are yet to be
     // implemented.
     def __new__(
         _cls,
         repo: PyObject,
         targetheads: PyObject,
         respectsize: bool
     ) -> PyResult<PartialDiscovery> {
         let index = repo.getattr(py, "changelog")?.getattr(py, "index")?;
         Self::create_instance(
             py,
             RefCell::new(Box::new(CorePartialDiscovery::new(
                 Index::new(py, index)?,
                 rev_pyiter_collect(py, &targetheads)?,
                 respectsize
             )))
         )
     }
 
     def addcommons(&self, commons: PyObject) -> PyResult<PyObject> {
         let mut inner = self.inner(py).borrow_mut();
         let commons_vec: Vec<Revision> = rev_pyiter_collect(py, &commons)?;
         inner.add_common_revisions(commons_vec)
             .map_err(|e| GraphError::pynew(py, e))?;
         Ok(py.None())
     }
 
     def addmissings(&self, missings: PyObject) -> PyResult<PyObject> {
         let mut inner = self.inner(py).borrow_mut();
         let missings_vec: Vec<Revision> = rev_pyiter_collect(py, &missings)?;
         inner.add_missing_revisions(missings_vec)
             .map_err(|e| GraphError::pynew(py, e))?;
         Ok(py.None())
     }
 
     def addinfo(&self, sample: PyObject) -> PyResult<PyObject> {
         let mut missing: Vec<Revision> = Vec::new();
         let mut common: Vec<Revision> = Vec::new();
         for info in sample.iter(py)? { // info is a pair (Revision, bool)
             let mut revknown = info?.iter(py)?;
             let rev: Revision = revknown.next().unwrap()?.extract(py)?;
             let known: bool = revknown.next().unwrap()?.extract(py)?;
             if known {
                 common.push(rev);
             } else {
                 missing.push(rev);
             }
         }
         let mut inner = self.inner(py).borrow_mut();
         inner.add_common_revisions(common)
             .map_err(|e| GraphError::pynew(py, e))?;
         inner.add_missing_revisions(missing)
             .map_err(|e| GraphError::pynew(py, e))?;
         Ok(py.None())
     }
 
     def hasinfo(&self) -> PyResult<bool> {
         Ok(self.inner(py).borrow().has_info())
     }
 
     def iscomplete(&self) -> PyResult<bool> {
         Ok(self.inner(py).borrow().is_complete())
     }
 
     def stats(&self) -> PyResult<PyDict> {
         let stats = self.inner(py).borrow().stats();
         let as_dict: PyDict = PyDict::new(py);
         as_dict.set_item(py, "undecided",
                          stats.undecided.map(
                              |l| l.to_py_object(py).into_object())
                              .unwrap_or_else(|| py.None()))?;
         Ok(as_dict)
     }
 
     def commonheads(&self) -> PyResult<PyObject> {
         py_set(
             py,
             &self.inner(py).borrow().common_heads()
                 .map_err(|e| GraphError::pynew(py, e))?
         )
     }
+
+    def takefullsample(&self, _headrevs: PyObject,
+                       size: usize) -> PyResult<PyObject> {
+        let mut inner = self.inner(py).borrow_mut();
+        let sample = inner.take_full_sample(size)
+            .map_err(|e| GraphError::pynew(py, e))?;
+        let as_vec: Vec<PyObject> = sample
+            .iter()
+            .map(|rev| rev.to_py_object(py).into_object())
+            .collect();
+        Ok(PyTuple::new(py, as_vec.as_slice()).into_object())
+    }
+
+    def takequicksample(&self, headrevs: PyObject,
+                        size: usize) -> PyResult<PyObject> {
+        let mut inner = self.inner(py).borrow_mut();
+        let revsvec: Vec<Revision> = rev_pyiter_collect(py, &headrevs)?;
+        let sample = inner.take_quick_sample(revsvec, size)
+            .map_err(|e| GraphError::pynew(py, e))?;
+        let as_vec: Vec<PyObject> = sample
+            .iter()
+            .map(|rev| rev.to_py_object(py).into_object())
+            .collect();
+        Ok(PyTuple::new(py, as_vec.as_slice()).into_object())
+    }
+
 });
 
 /// Create the module, with __package__ given from parent
 pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
     let dotted_name = &format!("{}.discovery", package);
     let m = PyModule::new(py, dotted_name)?;
     m.add(py, "__package__", package)?;
     m.add(
         py,
         "__doc__",
         "Discovery of common node sets - Rust implementation",
     )?;
     m.add_class::<PartialDiscovery>(py)?;
 
     let sys = PyModule::import(py, "sys")?;
     let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?;
     sys_modules.set_item(py, dotted_name, &m)?;
     // Example C code (see pyexpat.c and import.c) will "give away the
     // reference", but we won't because it will be consumed once the
     // Rust PyObject is dropped.
     Ok(m)
 }