( )⚙ D12211 rust: expose rank computation function to python

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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 32277

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: i32,
AlphareUnsubmitted
Done

Should be Revision instead of i32

Alphare: Should be `Revision` instead of `i32`
p2r: i32,
) -> 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: i32, p2r: i32)),
)?;
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)
} }