This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12211

rust: expose rank computation function to python
ClosedPublic

Authored by pacien on Feb 21 2022, 12:13 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG8b8054b8e5a7: rust: expose rank computation function to python

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

pacien created this revision.Feb 21 2022, 12:13 PM
Alphare requested changes to this revision.Mar 2 2022, 4:36 AM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
rust/hg-cpython/src/dagops.rs
41

Should be Revision instead of i32

This revision now requires changes to proceed.Mar 2 2022, 4:36 AM
pacien updated this revision to Diff 32394.Mar 2 2022, 1:16 PM
pacien marked an inline comment as done.Mar 2 2022, 1:17 PM

Amended.

Alphare accepted this revision.Mar 3 2022, 6:03 AM
This revision is now accepted and ready to land.Mar 3 2022, 6:03 AM
pacien added a commit: rHG8b8054b8e5a7: rust: expose rank computation function to python.Mar 3 2022, 6:07 AM
Closed by commit rHG8b8054b8e5a7: rust: expose rank computation function to python (authored by pacien). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/hg-cpython/src/dagops.rs (19 lines)

Diff 32455

rust/hg-cpython/src/dagops.rs

// dagops.rs // dagops.rs
// //
// Copyright 2019 Georges Racinet <georges.racinet@octobus.net> // Copyright 2019 Georges Racinet <georges.racinet@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Bindings for the `hg::dagops` module provided by the //! Bindings for the `hg::dagops` module provided by the
//! `hg-core` package. //! `hg-core` package.
//! //!
//! From Python, this will be seen as `mercurial.rustext.dagop` //! From Python, this will be seen as `mercurial.rustext.dagop`
use crate::{conversion::rev_pyiter_collect, exceptions::GraphError}; use crate::{conversion::rev_pyiter_collect, exceptions::GraphError};
use cpython::{PyDict, PyModule, PyObject, PyResult, Python}; use cpython::{PyDict, PyModule, PyObject, PyResult, Python};
use hg::dagops; use hg::dagops;
use hg::Revision; use hg::Revision;
use std::collections::HashSet; use std::collections::HashSet;
use vcsgraph::ancestors::node_rank;
use vcsgraph::graph::{Parents, Rank};
use crate::revlog::pyindex_to_graph; use crate::revlog::pyindex_to_graph;
/// Using the the `index`, return heads out of any Python iterable of Revisions /// Using the the `index`, return heads out of any Python iterable of Revisions
/// ///
/// This is the Rust counterpart for `mercurial.dagop.headrevs` /// This is the Rust counterpart for `mercurial.dagop.headrevs`
pub fn headrevs( pub fn headrevs(
py: Python, py: Python,
index: PyObject, index: PyObject,
revs: PyObject, revs: PyObject,
) -> PyResult<HashSet<Revision>> { ) -> PyResult<HashSet<Revision>> {
let mut as_set: HashSet<Revision> = rev_pyiter_collect(py, &revs)?; let mut as_set: HashSet<Revision> = rev_pyiter_collect(py, &revs)?;
dagops::retain_heads(&pyindex_to_graph(py, index)?, &mut as_set) dagops::retain_heads(&pyindex_to_graph(py, index)?, &mut as_set)
.map_err(|e| GraphError::pynew(py, e))?; .map_err(|e| GraphError::pynew(py, e))?;
Ok(as_set) Ok(as_set)
} }
/// Computes the rank, i.e. the number of ancestors including itself,
/// of a node represented by its parents.
pub fn rank(
py: Python,
index: PyObject,
p1r: Revision,
AlphareUnsubmitted
Done

Should be Revision instead of i32

Alphare: Should be `Revision` instead of `i32`
p2r: Revision,
) -> PyResult<Rank> {
node_rank(&pyindex_to_graph(py, index)?, &Parents([p1r, p2r]))
.map_err(|e| GraphError::pynew_from_vcsgraph(py, e))
}
/// Create the module, with `__package__` given from parent /// Create the module, with `__package__` given from parent
pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> { pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
let dotted_name = &format!("{}.dagop", package); let dotted_name = &format!("{}.dagop", package);
let m = PyModule::new(py, dotted_name)?; let m = PyModule::new(py, dotted_name)?;
m.add(py, "__package__", package)?; m.add(py, "__package__", package)?;
m.add(py, "__doc__", "DAG operations - Rust implementation")?; m.add(py, "__doc__", "DAG operations - Rust implementation")?;
m.add( m.add(
py, py,
"headrevs", "headrevs",
py_fn!(py, headrevs(index: PyObject, revs: PyObject)), py_fn!(py, headrevs(index: PyObject, revs: PyObject)),
)?; )?;
m.add(
py,
"rank",
py_fn!(py, rank(index: PyObject, p1r: Revision, p2r: Revision)),
)?;
let sys = PyModule::import(py, "sys")?; let sys = PyModule::import(py, "sys")?;
let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?; let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?;
sys_modules.set_item(py, dotted_name, &m)?; sys_modules.set_item(py, dotted_name, &m)?;
// Example C code (see pyexpat.c and import.c) will "give away the // 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 // reference", but we won't because it will be consumed once the
// Rust PyObject is dropped. // Rust PyObject is dropped.
Ok(m) Ok(m)
} }