pybevy 0.2.1

PyBevy: A Python Real-Time Engine Built on Bevy
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

use pyo3::{IntoPyObjectExt, exceptions::PyTypeError, prelude::*, types::PyType};

/// Per-system local state, persisted across system invocations.
///
/// Usage: `def my_system(counter: Local[int])` creates a per-system `int`
/// initialized to `int()` (0) on the first run.
#[pyclass(name = "Local")]
pub struct PyLocal {
    #[pyo3(get, name = "value_type")]
    pub(crate) ty: Py<PyType>,

    #[pyo3(get)]
    pub(crate) value: Py<PyAny>,
}

#[pymethods]
impl PyLocal {
    /// Create a `Local[SomeType]` with a default-constructed value.
    ///
    /// The type must be callable with no arguments (i.e. have a no-arg constructor).
    #[classmethod]
    #[pyo3(signature = (key, /))]
    pub fn __class_getitem__(
        cls: &Bound<'_, PyType>,
        key: &Bound<'_, PyAny>,
    ) -> PyResult<Py<PyAny>> {
        let ty = key.cast::<PyType>().map_err(|_| {
            PyTypeError::new_err(format!("Local[...] expects a type, got {}", key.get_type()))
        })?;
        let value = key.call0().map_err(|e| {
            PyTypeError::new_err(format!(
                "Local[{}]: type must be callable with no arguments to create a default value ({})",
                ty, e
            ))
        })?;
        Self {
            ty: ty.clone().unbind(),
            value: value.unbind(),
        }
        .into_py_any(cls.py())
    }

    #[new]
    pub fn new(value: Bound<'_, PyAny>) -> Self {
        Self {
            ty: value.get_type().into(),
            value: value.unbind(),
        }
    }

    #[setter]
    pub fn set_value(&mut self, py: Python, value: Bound<'_, PyAny>) -> PyResult<()> {
        if !value.get_type().is(self.ty.bind(py)) {
            return Err(PyTypeError::new_err(format!(
                "Expected type {}, but got {}",
                self.ty,
                value.get_type()
            )));
        }

        self.value = value.unbind();

        Ok(())
    }

    /// Proxy attribute access to the wrapped value
    pub fn __getattr__(&self, py: Python, name: &str) -> PyResult<Py<PyAny>> {
        self.value.bind(py).getattr(name).map(|v| v.unbind())
    }

    /// Proxy attribute setting to the wrapped value
    pub fn __setattr__(&mut self, py: Python, name: &str, value: Bound<'_, PyAny>) -> PyResult<()> {
        self.value.bind(py).setattr(name, value)
    }
}