breezyshim 0.7.14

Rust shim around the Breezy Python API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::branch::PyBranch;
use crate::debian::error::Error;
use crate::debian::upstream::PyUpstreamSource;
use crate::debian::TarballKind;
use crate::tree::PyTree;
use crate::workingtree::PyWorkingTree;
use crate::RevisionId;
use pyo3::prelude::*;
use pyo3::types::PyDict;
use std::collections::HashMap;
use std::path::{Path, PathBuf};

/// Import new tarballs.
///
/// # Arguments
/// * `tree` - Working tree to operate in
/// * `subpath` - Subpath to operate in
/// * `tarball_filenames` - List of tarball filenames as tuples with (path, component)
/// * `package` - Package name
/// * `version` - New upstream version to merge
/// * `current_version` - Current upstream version in tree
/// * `upstream_branch` - Optional upstream branch to merge from
/// * `upstream_revisions` - Dictionary mapping versions to upstream revisions
/// * `merge_type` - Merge type
/// * `committer` - Committer string to use
/// * `files_excluded` - Files to exclude
///
/// # Returns
/// List with (component, tag, revid, pristine_tar_imported, subpath) tuples
pub fn do_import(
    tree: &dyn PyWorkingTree,
    subpath: &Path,
    tarball_filenames: &[&Path],
    package: &str,
    version: &str,
    current_version: Option<&str>,
    upstream_branch: &dyn PyBranch,
    upstream_revisions: HashMap<TarballKind, (RevisionId, PathBuf)>,
    merge_type: Option<&str>,
    force: bool,
    force_pristine_tar: bool,
    committer: Option<&str>,
    files_excluded: Option<&[&Path]>,
) -> Result<Vec<(TarballKind, String, RevisionId, Option<bool>, PathBuf)>, Error> {
    Python::attach(|py| {
        let m = PyModule::import(py, "breezy.plugins.debian.merge_upstream").unwrap();
        let do_import = m.getattr("do_import").unwrap();
        let kwargs = PyDict::new(py);
        kwargs.set_item("tree", tree.to_object(py))?;
        kwargs.set_item("subpath", subpath.to_string_lossy().to_string())?;
        kwargs.set_item("tarball_filenames", tarball_filenames.to_vec())?;
        kwargs.set_item("package", package)?;
        kwargs.set_item("version", version)?;
        kwargs.set_item("current_version", current_version)?;
        kwargs.set_item("upstream_branch", upstream_branch.to_object(py))?;
        kwargs.set_item("upstream_revisions", upstream_revisions)?;
        kwargs.set_item("merge_type", merge_type)?;
        kwargs.set_item("force", force)?;
        kwargs.set_item("force_pristine_tar", force_pristine_tar)?;
        kwargs.set_item("committer", committer)?;
        kwargs.set_item("files_excluded", files_excluded)?;
        Ok(do_import.call((), Some(&kwargs))?.extract()?)
    })
}

/// Find tarballs for a specific package and version.
///
/// # Arguments
/// * `orig_dir` - Directory containing orig tarballs
/// * `tree` - The working tree
/// * `package` - Package name
/// * `version` - Version string
/// * `locations` - List of additional locations to search for tarballs
///
/// # Returns
/// A list of paths to found tarballs, or an error
pub fn get_tarballs(
    orig_dir: &Path,
    tree: &dyn PyTree,
    package: &str,
    version: &str,
    locations: &[&Path],
) -> Result<Vec<PathBuf>, Error> {
    Python::attach(|py| {
        let m = PyModule::import(py, "breezy.plugins.debian.merge_upstream").unwrap();
        let get_tarballs = m.getattr("get_tarballs").unwrap();
        Ok(get_tarballs
            .call1((
                orig_dir,
                tree.to_object(py),
                package,
                version,
                locations.to_vec(),
            ))?
            .extract()?)
    })
}

/// Get revision IDs for already imported upstream versions.
///
/// # Arguments
/// * `upstream_source` - The upstream source to check
/// * `package` - Package name
/// * `new_upstream_version` - The new upstream version being imported
///
/// # Returns
/// A list of tuples with component information: (kind, version, revid, pristine_tar_imported, path)
pub fn get_existing_imported_upstream_revids<T: PyUpstreamSource>(
    upstream_source: &T,
    package: &str,
    new_upstream_version: &str,
) -> Result<Vec<(TarballKind, String, RevisionId, Option<bool>, PathBuf)>, Error> {
    Python::attach(|py| {
        let m = PyModule::import(py, "breezy.plugins.debian.merge_upstream").unwrap();
        let get_existing_imported_upstream_revids =
            m.getattr("get_existing_imported_upstream_revids").unwrap();
        Ok(get_existing_imported_upstream_revids
            .call1((upstream_source.as_pyobject(), package, new_upstream_version))?
            .extract()?)
    })
}