wingfoil-python 4.0.1

python bindings for wingfoil - graph based stream processing framework
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use pyo3::prelude::*;
use pyo3::types::PyAny;

pub struct PyElement(Option<Py<PyAny>>);

impl PyElement {
    pub fn none() -> Self {
        PyElement(None)
    }

    pub fn new(val: Py<PyAny>) -> Self {
        PyElement(Some(val))
    }

    pub fn as_ref(&self) -> &Py<PyAny> {
        self.0.as_ref().unwrap()
    }

    pub fn value(&self) -> Py<PyAny> {
        Python::attach(|py| self.as_ref().clone_ref(py))
    }
}

impl Default for PyElement {
    fn default() -> Self {
        Python::attach(|py| PyElement(Some(py.None())))
    }
}

impl std::fmt::Debug for PyElement {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        Python::attach(|py| {
            let res = self
                .as_ref()
                .call_method0(py, "__str__")
                .unwrap()
                .extract::<String>(py)
                .unwrap();
            write!(f, "{res}")
        })
    }
}

impl Clone for PyElement {
    fn clone(&self) -> Self {
        match &self.0 {
            Some(inner) => Python::attach(|py| PyElement(Some(inner.clone_ref(py)))),
            None => PyElement(None),
        }
    }
}

impl std::ops::Not for PyElement {
    type Output = PyElement;

    fn not(self) -> Self::Output {
        Python::attach(|py| {
            let res = self.as_ref().call_method0(py, "__neg__").unwrap();
            PyElement::new(res)
        })
    }
}

impl std::ops::Add for PyElement {
    type Output = PyElement;

    fn add(self, rhs: PyElement) -> Self::Output {
        Python::attach(|py| {
            let res = self
                .as_ref()
                .call_method1(py, "__add__", (rhs.as_ref(),))
                .unwrap();
            PyElement::new(res)
        })
    }
}

impl std::ops::Sub for PyElement {
    type Output = PyElement;

    fn sub(self, rhs: PyElement) -> Self::Output {
        Python::attach(|py| {
            let res = self
                .as_ref()
                .call_method1(py, "__sub__", (rhs.as_ref(),))
                .unwrap();
            PyElement::new(res)
        })
    }
}

impl PartialEq for PyElement {
    fn eq(&self, other: &Self) -> bool {
        match (&self.0, &other.0) {
            (Some(a), Some(b)) => {
                Python::attach(|py| {
                    // keep cloned Py<T> alive outside bind()
                    let a_obj = a.clone_ref(py);
                    let b_obj = b.clone_ref(py);

                    // bind inside attach so temporary doesn't drop too early
                    let a_bound = a_obj.bind(py);
                    let b_bound = b_obj.bind(py);

                    match a_bound.rich_compare(b_bound, pyo3::basic::CompareOp::Eq) {
                        Ok(obj) => obj.is_truthy().unwrap_or(false),
                        Err(_) => false,
                    }
                })
            }
            (None, None) => true,
            _ => false,
        }
    }
}

impl Eq for PyElement {}

use std::hash::{Hash, Hasher};

impl Hash for PyElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        match &self.0 {
            Some(obj) => {
                Python::attach(|py| {
                    let obj_ref = obj.clone_ref(py);
                    let bound = obj_ref.bind(py);
                    match bound.hash() {
                        Ok(hash_val) => state.write_isize(hash_val),
                        Err(err) => panic!("hash failed, {err:?}"),
                    }
                });
            }
            None => {
                panic!("can not hash empty PyElement")
            }
        }
    }
}