wip: Prevent Writing to 'var allow for #var

Author: wonkodv

examples/Cargo.toml

@@ -15,6 +15,10 @@ path = "matplotlib.rs"
 name = "rust-fn"
 path = "rust-fn.rs"
 
+[[example]]
+name = "var-write"
+path = "var-write.rs"
+
 [dependencies]
 inline-python = { path = ".." }
 pyo3 = "0.11.0"

examples/var-write.rs

@@ -0,0 +1,12 @@
+use inline_python::python;
+
+fn main() {
+	let mut x = 42;
+	python! {
+		#x = #x - 6
+		assert 'x == 42
+		assert #x == 36
+
+	}
+    assert_eq!(x, 36);
+}

macros/src/embed_python.rs

@@ -78,9 +78,11 @@ impl EmbedPython {
 						} else {
 							unreachable!()
 						};
-						let name_str = format!("_RUST_{}", name);
+						let name_str = name.to_string();
+						self.python.push_str("_RUST_IMMUT_VARS['");
 						self.python.push_str(&name_str);
-						self.loc.column += name_str.chars().count() - 6 + 1;
+						self.python.push_str("']");
+						self.loc.column += name_str.chars().count() + 1;
 						self.variables.entry(name_str).or_insert(name);
 					} else if x.as_char() == '#' && x.spacing() == Spacing::Joint {
 						// Convert '##' to '//', because otherwise it's

macros/src/lib.rs

@@ -51,9 +51,9 @@ fn python_impl(input: TokenStream) -> Result<TokenStream, TokenStream> {
 	Ok(quote! {
 		::inline_python::FromInlinePython::from_python_macro(
 			#bytecode,
-			|globals| {
+			|rust_vars| {
 				#(
-					globals
+					rust_vars
 						.set_item(#varname, #var)
 						.expect("Unable to convert variable to Python");
 				)*

src/context.rs

@@ -66,9 +66,35 @@ impl Context {
 	}
 
 	fn try_new(py: Python) -> PyResult<Self> {
-		Ok(Self {
-			globals: py.import("__main__")?.dict().copy()?.into(),
-		})
+		let rust_vars = PyDict::new(py);
+		let globals = PyDict::new(py);
+		let ctx = Self { globals: globals.into() };
+		ctx.run_with_gil(
+			py,
+			inline_python_macros::python! {
+				class RustVars:
+					__slots__ = ("_dict", "_mutable")
+					def __init__(self, mutable:bool):
+						self._dict = dict()
+						self._mutable = mutable
+
+					def __setitem__(self, key, value):
+						if self._mutable:
+							self._dict[key] = value
+						else:
+							raise TypeError("You are trying to write to "+'\''+key+" which is read-only. Try #"+key)
+
+					def __getitem__(self, key):
+						return self._dict[key]
+
+				_RUST_MUT_VARS = RustVars(True)
+				_RUST_IMMUT_VARS = RustVars(False)
+
+				del RustVars
+				from builtins import *
+			},
+		);
+		Ok(ctx)
 	}
 
 	/// Get the globals as dictionary.
@@ -192,7 +218,16 @@ impl Context {
 	///
 	/// This function panics if the Python code fails.
 	pub fn run_with_gil<F: FnOnce(&PyDict)>(&self, py: Python<'_>, code: PythonBlock<F>) {
-		(code.set_variables)(self.globals(py));
+		let immut_vars = self
+			.globals(py)
+			.get_item("_RUST_IMMUT_VARS")
+			.unwrap()
+			.getattr("_dict")
+			.unwrap()
+			.cast_as::<PyDict>()
+			.unwrap();
+
+		(code.set_variables)(&immut_vars);
 		match run_python_code(py, self, code.bytecode) {
 			Ok(_) => (),
 			Err(e) => {
@@ -201,4 +236,8 @@ impl Context {
 			}
 		}
 	}
+
+	pub fn try_run<F: FnOnce(&PyDict)>(&self, code: PythonBlock<F>) -> Result<(), pyo3::PyErr> {
+		todo!();
+	}
 }

src/lib.rs

@@ -21,7 +21,7 @@
 //! ## Using Rust variables
 //!
 //! To reference Rust variables, use `'var`, as shown in the example above.
-//! `var` needs to implement [`pyo3::ToPyObject`].
+//! `var` needs to implement [`pyo3::ToPyObject`] and can only be read!
 //!
 //! ## Re-using a Python context
 //!
@@ -108,6 +108,7 @@
 //!
 //! Everything else should work fine.
 
+pub use inline_python_macros::python;
 use pyo3::{types::PyDict, Python};
 
 mod context;
@@ -132,7 +133,6 @@ pub use pyo3;
 ///     as [`Context::run`].
 ///
 /// See [the crate's module level documentation](index.html) for examples.
-pub use inline_python_macros::python;
 
 #[doc(hidden)]
 pub trait FromInlinePython<F: FnOnce(&PyDict)> {