Convert from eval to callExprString API

python/doc/index.md

@@ -11,7 +11,7 @@ $ nix run github:NixOS/nix#nix.python-bindings.exampleEnv
 Python 3.10.8 (main, Oct 11 2022, 11:35:05) [GCC 11.3.0] on linux
 Type "help", "copyright", "credits" or "license" for more information.
 >>> import nix
->>> nix.eval('"Hello ${name}!"', vars=dict(name="Python"))
+>>> nix.callExprString('"Hello ${name}!"', arg={"name": "Python"}))
 'Hello Python!'
 ```
 

python/examples/buildPythonApplication/hello/__init__.py

@@ -1,4 +1,4 @@
 import nix
 
 def greet():
- print("Evaluating 1 + 1 in Nix gives: " + str(nix.eval("1 + 1")))
+ print("Evaluating 1 + 1 in Nix gives: " + str(nix.callExprString("_: 1 + 1", None)))

python/src/eval.cc

@@ -17,17 +17,16 @@ const char * currentExceptionTypeName()
  return res ? res : "(null)";
 }
 
-static PyObject * _eval(const std::string & expression, PyObject * vars)
+static PyObject * _eval(const std::string & expression, PyObject * argument)
 {
  nix::Strings storePath;
  nix::EvalState state(storePath, nix::openStore());
 
- nix::Env * env = nullptr;
- auto staticEnv = pythonToNixEnv(state, vars, &env);
- if (!staticEnv) {
+ auto nixArgument = pythonToNixValue(state, argument);
+ if (!nixArgument) {
  return nullptr;
  }
- auto staticEnvPointer = std::make_shared<nix::StaticEnv>(*staticEnv);
+ nix::Value fun;
  nix::Value v;
 
 
@@ -44,25 +43,28 @@ static PyObject * _eval(const std::string & expression, PyObject * vars)
  });
 
  // TODO: Should the "." be something else here?
- auto e = state.parseExprFromString(expression, ".", staticEnvPointer);
- e->eval(state, *env, v);
+ auto e = state.parseExprFromString(expression, ".");
+ state.eval(e, fun);
+ // TODO: Add position
+ state.callFunction(fun, *nixArgument, v, noPos);
  state.forceValueDeep(v);
  }
 
  nix::PathSet context;
  return nixToPythonObject(state, v, context);
 }
 
+// TODO: Rename this function to callExprString, matching the Python name
 PyObject * eval(PyObject * self, PyObject * args, PyObject * keywds)
 {
  PyObject * expressionObject;
- PyObject * vars = nullptr;
+ PyObject * argument = nullptr;
 
- const char * kwlist[] = {"expression", "vars", nullptr};
+ const char * kwlist[] = {"expression", "arg", nullptr};
 
  // See https://docs.python.org/3/c-api/arg.html for the magic string
  if (!PyArg_ParseTupleAndKeywords(
- args, keywds, "U|O!", const_cast<char **>(kwlist), &expressionObject, &PyDict_Type, &vars)) {
+ args, keywds, "UO", const_cast<char **>(kwlist), &expressionObject, &argument)) {
  return nullptr;
  }
 
@@ -75,7 +77,7 @@ PyObject * eval(PyObject * self, PyObject * args, PyObject * keywds)
  std::string expression(expressionBase, expressionSize);
 
  try {
- return _eval(expression, vars);
+ return _eval(expression, argument);
  } catch (nix::ThrownError & e) {
  return PyErr_Format(ThrownNixError, "%s", e.message().c_str());
  } catch (nix::Error & e) {

python/src/internal/python-to-nix.hh

@@ -9,5 +9,4 @@ namespace nix::python {
 
 nix::Value * pythonToNixValue(nix::EvalState & state, PyObject * obj);
 
-std::optional<nix::StaticEnv> pythonToNixEnv(nix::EvalState & state, PyObject * vars, nix::Env ** env);
 } // namespace nix::python

python/src/python-module.cc

@@ -15,7 +15,7 @@ PyObject * ThrownNixError = nullptr;
 PyObject * NixError = nullptr;
 
 static PyMethodDef NixMethods[] = {
- {"eval", (PyCFunction) eval, METH_VARARGS | METH_KEYWORDS, "Eval nix expression"}, {NULL, NULL, 0, NULL}};
+ {"callExprString", (PyCFunction) eval, METH_VARARGS | METH_KEYWORDS, "Eval nix expression"}, {NULL, NULL, 0, NULL}};
 
 static struct PyModuleDef nixmodule = {
  PyModuleDef_HEAD_INIT, "nix", "Nix expression bindings",

python/src/python-to-nix.cc

@@ -130,36 +130,4 @@ nix::Value * pythonToNixValue(nix::EvalState & state, PyObject * obj)
  }
  return v;
 }
-
-std::optional<nix::StaticEnv> pythonToNixEnv(nix::EvalState & state, PyObject * vars, nix::Env ** env)
-{
- Py_ssize_t pos = 0;
- PyObject *key = nullptr, *val = nullptr;
-
- *env = &state.allocEnv(vars ? PyDict_Size(vars) : 0);
- (*env)->up = &state.baseEnv;
-
- nix::StaticEnv staticEnv(false, state.staticBaseEnv.get());
-
- if (!vars) {
- return staticEnv;
- }
-
- auto displ = 0;
- while (PyDict_Next(vars, &pos, &key, &val)) {
- auto name = checkAttrKey(key);
- if (!name) {
- return {};
- }
-
- auto attrVal = pythonToNixValue(state, val);
- if (!attrVal) {
- return {};
- }
- staticEnv.vars.emplace_back(state.symbols.create(name), displ);
- (*env)->values[displ++] = attrVal;
- }
-
- return staticEnv;
-}
 } // namespace nix::python

python/tests.py

@@ -5,64 +5,65 @@
 class TestPythonNix(unittest.TestCase):
  def test_dict(self):
  val = dict(a=1)
- self.assertEqual(nix.eval("a", vars=dict(a=val)), val)
+ self.assertEqual(nix.callExprString("{ a }: a", arg=dict(a=val)), val)
 
  def test_string(self):
- self.assertEqual(nix.eval("a", vars=dict(a="foo")), "foo")
+ self.assertEqual(nix.callExprString("{ a }: a", arg=dict(a="foo")), "foo")
 
  def test_bool(self):
- self.assertEqual(nix.eval("a", vars=dict(a=True)), True)
+ self.assertEqual(nix.callExprString("{ a }: a", arg=dict(a=True)), True)
 
  def test_none(self):
- self.assertEqual(nix.eval("a", vars=dict(a=None)), None)
+ self.assertEqual(nix.callExprString("{ a }: a", arg=dict(a=None)), None)
 
  def test_ifd(self):
  expression = """
+ {}:
  builtins.readFile (derivation {
  name = "test";
  args = [ "-c" "printf \\"%s\\" test > $out" ];
  builder = "/bin/sh";
  system = builtins.currentSystem;
  })
  """
- self.assertEqual(nix.eval(expression, vars=dict()), "test")
+ self.assertEqual(nix.callExprString(expression, arg={}), "test")
 
  def test_throw(self):
  errorString = "hello hi there\ntest"
  with self.assertRaises(nix.ThrownNixError) as cm:
- nix.eval("throw str", vars=dict(str=errorString))
+ nix.callExprString("{ str }: throw str", arg=dict(str=errorString))
  self.assertEqual(cm.exception.args[0], errorString)
 
  def test_syntax_error(self):
  with self.assertRaises(nix.NixError) as cm:
- nix.eval("{")
+ nix.callExprString("{", arg={})
 
  def test_GIL_case(self):
  with self.assertRaises(nix.ThrownNixError) as cm:
- nix.eval("{ a = throw \"nope\"; }")
+ nix.callExprString("{}: { a = throw \"nope\"; }", arg={})
  self.assertEqual(cm.exception.args[0], "nope")
 
  def test_infinity(self):
  with self.assertRaises(nix.NixError):
- nix.eval("let x = { inherit x; }; in x")
+ nix.callExprString("{}: let x = { inherit x; }; in x", arg={})
 
  def test_null_expression(self):
  # Null characters should be allowed in expressions, even if they aren't
  # very useful really, though at least null's should be supported in
  # strings in the future https://github.com/NixOS/nix/issues/1307)
- self.assertEqual(nix.eval("\"ab\x00cd\""), "ab")
+ self.assertEqual(nix.callExprString("{}: \"ab\x00cd\"", arg={}), "ab")
 
  def test_throw_null(self):
  with self.assertRaises(nix.ThrownNixError) as cm:
- nix.eval("throw \"hello\x00there\"")
+ nix.callExprString("{}: throw \"hello\x00there\"", arg={})
  self.assertEqual(cm.exception.args[0], "hello")
 
  def test_booleans(self):
- self.assertIs(nix.eval("assert a == true; a", vars=dict(a=True)), True)
- self.assertIs(nix.eval("assert a == false; a", vars=dict(a=False)), False)
+ self.assertIs(nix.callExprString("{ a }: assert a == true; a", arg=dict(a=True)), True)
+ self.assertIs(nix.callExprString("{ a }: assert a == false; a", arg=dict(a=False)), False)
 
  def test_null(self):
- self.assertIs(nix.eval("assert a == null; a", vars=dict(a=None)), None)
+ self.assertIs(nix.callExprString("{ a }: assert a == null; a", arg=dict(a=None)), None)
 
 if __name__ == '__main__':
  unittest.main()