zpack 0.1.17

A fast, configurable package manager which builds programs from source
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

use pyo3::{exceptions::PyRuntimeError, prelude::*};

use anyhow::Result;

pub mod entry;
pub mod package;
pub mod spec;
pub mod util;

fn register_submodule(
    parent: &Bound<'_, PyModule>,
    submodule: &Bound<'_, PyModule>,
    full_name: &str,
) -> PyResult<()> {
    parent.add_submodule(submodule)?;

    // Register in sys.modules
    parent
        .py()
        .import("sys")?
        .getattr("modules")?
        .set_item(full_name, submodule)?;

    Ok(())
}

fn register_module_package_outline(
    parent_module: &Bound<'_, PyModule>,
) -> PyResult<()> {
    let child_module = PyModule::new(parent_module.py(), "outline")?;
    use package::outline;

    child_module.add_class::<outline::PackageOutline>()?;

    register_submodule(parent_module, &child_module, "zpack.package.outline")?;

    Ok(())
}

fn register_module_package_constraint(
    parent_module: &Bound<'_, PyModule>,
) -> PyResult<()> {
    let child_module = PyModule::new(parent_module.py(), "constraint")?;
    use package::constraint;

    child_module.add_class::<constraint::Cmp>()?;
    child_module.add_class::<constraint::CmpType>()?;
    child_module.add_class::<constraint::Depends>()?;
    child_module.add_class::<constraint::IfThen>()?;
    child_module.add_class::<constraint::Maximize>()?;
    child_module.add_class::<constraint::Minimize>()?;
    child_module.add_class::<constraint::NumOf>()?;
    child_module.add_class::<constraint::SpecOption>()?;
    child_module.add_class::<constraint::Value>()?;

    register_submodule(
        parent_module,
        &child_module,
        "zpack.package.constraint",
    )?;

    Ok(())
}

fn register_module_package_version(
    parent_module: &Bound<'_, PyModule>,
) -> PyResult<()> {
    let child_module = PyModule::new(parent_module.py(), "version")?;

    child_module.add_class::<package::version::Version>()?;

    register_submodule(parent_module, &child_module, "zpack.package.version")?;

    Ok(())
}

fn register_module_package(
    parent_module: &Bound<'_, PyModule>,
) -> PyResult<()> {
    let child_module = PyModule::new(parent_module.py(), "package")?;

    register_module_package_outline(&child_module)?;
    register_module_package_constraint(&child_module)?;
    register_module_package_version(&child_module)?;

    register_submodule(parent_module, &child_module, "zpack.package")?;

    Ok(())
}

#[pyfunction]
fn init_tracing() {
    Python::attach(|_py| {
        tracing::subscriber::set_global_default(
            crate::util::subscriber::subscriber(),
        )
        .expect("Failed to set subscriber");
    });

    tracing::warn!("tracing activated");
}

#[pyfunction]
fn main_entry() -> PyResult<()> {
    entry::entry().map_err(|e| PyRuntimeError::new_err(e.to_string()))
}

#[pymodule]
fn zpack(m: &Bound<'_, PyModule>) -> PyResult<()> {
    register_module_package(m)?;

    m.add_function(wrap_pyfunction!(init_tracing, m)?)?;

    m.add_function(wrap_pyfunction!(main_entry, m)?)?;

    Ok(())
}