Python bindings

.gitignore

@@ -21,3 +21,7 @@
 
 # pre-commit-hooks
 /.pre-commit-config.yaml
+
+# Python virtual env
+.venv/
+venv/

Cargo.toml

@@ -80,6 +80,7 @@ members = [
     "lsp/nls",
     "utilities",
     "nickel-wasm-repl",
+    "pyckel",
 ]
 
 # Enable this to use flamegraphs

flake.nix

@@ -189,29 +189,38 @@
           # Customize source filtering as Nickel uses non-standard-Rust files like `*.lalrpop`.
           src = filterNickelSrc craneLib.filterCargoSources;
 
-          # Args passed to all `cargo` invocations by Crane.
-          cargoExtraArgs = "--frozen --offline --workspace";
-        in
-        rec {
+          # set of cargo args common to all builds
+          cargoBuildExtraArgs = "--frozen --offline";
+
           # Build *just* the cargo dependencies, so we can reuse all of that work (e.g. via cachix) when running in CI
           cargoArtifacts = craneLib.buildDepsOnly {
-            inherit
-              src
-              cargoExtraArgs;
+            inherit src;
+            cargoExtraArgs = "${cargoBuildExtraArgs} --workspace";
+            # pyo3 needs a Python interpreter in the build environment
+            # https://pyo3.rs/v0.17.3/building_and_distribution#configuring-the-python-version
+            buildInputs = [ pkgs.python3 ];
           };
 
-          nickel = craneLib.buildPackage {
-            inherit
-              src
-              cargoExtraArgs
-              cargoArtifacts;
-          };
+          buildPackage = packageName:
+            craneLib.buildPackage {
+              inherit
+                src
+                cargoArtifacts;
+
+              cargoExtraArgs = "${cargoBuildExtraArgs} --package ${packageName}";
+            };
+
+
+        in
+        rec {
+          nickel = buildPackage "nickel-lang";
+          lsp-nls = buildPackage "nickel-lang-lsp";
+          nickel-wasm-repl = buildPackage "nickel-repl";
 
           rustfmt = craneLib.cargoFmt {
             # Notice that unlike other Crane derivations, we do not pass `cargoArtifacts` to `cargoFmt`, because it does not need access to dependencies to format the code.
             inherit src;
 
-            # We don't reuse the `cargoExtraArgs` in scope because `cargo fmt` does not accept nor need any of `--frozen`, `--offline` or `--workspace`
             cargoExtraArgs = "--all";
 
             # `-- --check` is automatically prepended by Crane
@@ -221,12 +230,11 @@
           clippy = craneLib.cargoClippy {
             inherit
               src
-              cargoExtraArgs
               cargoArtifacts;
 
+            cargoExtraArgs = cargoBuildExtraArgs;
             cargoClippyExtraArgs = "--all-targets -- --deny warnings --allow clippy::new-without-default --allow clippy::match_like_matches_macro";
           };
-
         };
 
       makeDevShell = { rust }: pkgs.mkShell {
@@ -241,6 +249,7 @@
           pkgs.nodejs
           pkgs.node2nix
           pkgs.nodePackages.markdownlint-cli
+          pkgs.python3
         ];
 
         shellHook = (pre-commit-builder { inherit rust; checkFormat = true; }).shellHook + ''
@@ -395,6 +404,8 @@
       checks = {
         inherit (mkCraneArtifacts { })
           nickel
+          lsp-nls
+          nickel-wasm-repl
           clippy
           rustfmt;
         # An optimizing release build is long: eschew optimizations in checks by

pyckel/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "pyckel"
+version = "0.3.1"
+authors = ["Nickel team"]
+license = "MIT"
+readme = "README.md"
+description = "Python bindings for the Nickel programming language."
+homepage = "https://nickel-lang.org"
+repository = "https://github.com/tweag/nickel"
+keywords = ["configuration", "language", "nix", "nickel"]
+edition = "2018"
+
+[dependencies]
+nickel-lang = {default-features = false, path = "../", version = "0.3.1" }
+pyo3 = { version = "0.17.3", features = ["extension-module"] }
+
+[lib]
+crate-type = ["cdylib", "rlib"]

pyckel/README.md

@@ -0,0 +1,21 @@
+# pyckel
+
+Python bindings to use Nickel.
+
+## Install
+
+```shell
+pip install .
+```
+
+## Use
+
+```python
+import pyckel
+
+result = pyckel.run("let x = 1 in { y = x + 2 }")
+print(result)
+# {
+#   "y": 3
+# }
+```

pyckel/pyproject.toml

@@ -0,0 +1,6 @@
+[build-system]
+requires = ["maturin>=0.14,<0.15"]
+build-backend = "maturin"
+
+[tool.maturin]
+

pyckel/src/lib.rs

@@ -0,0 +1,68 @@
+use std::io::Cursor;
+
+use nickel_lang::{
+    error::{Error, SerializationError},
+    eval::cache::CBNCache,
+    program::Program,
+    serialize,
+};
+
+use pyo3::{create_exception, exceptions::PyException, prelude::*};
+
+create_exception!(pyckel, NickelException, PyException);
+
+// see https://pyo3.rs/v0.17.3/function/error_handling.html#foreign-rust-error-types
+struct NickelError(Error);
+struct NickelSerializationError(SerializationError);
+
+impl From<Error> for NickelError {
+    fn from(value: Error) -> Self {
+        Self(value)
+    }
+}
+
+impl std::convert::From<NickelError> for PyErr {
+    fn from(err: NickelError) -> PyErr {
+        match err {
+            // TODO better exceptions
+            NickelError(error) => NickelException::new_err(format!("{error:?}")),
+        }
+    }
+}
+
+impl From<SerializationError> for NickelSerializationError {
+    fn from(value: SerializationError) -> Self {
+        Self(value)
+    }
+}
+
+impl std::convert::From<NickelSerializationError> for PyErr {
+    fn from(err: NickelSerializationError) -> PyErr {
+        match err {
+            // TODO better exceptions
+            NickelSerializationError(error) => NickelException::new_err(format!("{error:?}")),
+        }
+    }
+}
+
+/// Evaluate from a Python str of a Nickel expression to a Python str of the resulting JSON.
+#[pyfunction]
+pub fn run(s: String) -> PyResult<String> {
+    let mut program: Program<CBNCache> =
+        Program::new_from_source(Cursor::new(s.to_string()), "python")?;
+
+    let term = program.eval_full().map_err(NickelError)?;
+
+    serialize::validate(serialize::ExportFormat::Json, &term).map_err(NickelSerializationError)?;
+
+    let json_string = serialize::to_string(serialize::ExportFormat::Json, &term)
+        .map_err(NickelSerializationError)?;
+
+    Ok(json_string)
+}
+
+#[pymodule]
+pub fn pyckel(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(run, m)?)?;
+    Ok(())
+}