chore: Fetch tket-c-api from conan remote (#1002)

This greatly simplifies the build! No setup is required anymore. Just
`uv run cargo build` and you are good to go -- or `cargo build` with
`conan` in your path. In addition, no C++ compilation should happen if
you are on one of the supported platforms (Linux X86, Mac ARM, Mac X86
or Windows X86).

As before, If you do not want to use `conan`, you just need to set
`TKET_C_API_PATH` to point to the install folder of a compiled dynamic
library of `tket-c-api`.

Author: lmondada

.github/actions/tket-c-api/action.yml

@@ -32,9 +32,8 @@ runs:
       if: steps.cache.outputs.cache-hit != 'true'
       shell: bash
       run: |
-        cd tket1-passes/tket-c-api
-        PACKAGE_NAME="tket-c-api/$(conan inspect . --format=json | jq -r '.version')"
-        CONAN_OUTPUT=$(conan create . --build=missing --options="$PACKAGE_NAME:shared=True" --format=json)
+        cd tket1-passes
+        CONAN_OUTPUT=$(conan install . --build=missing --options="tket-c-api/*:shared=True" --format=json)
         CONAN_LIB_FOLDER=$(echo "$CONAN_OUTPUT" | jq -r ".graph.nodes.\"1\".package_folder")
         cp -r $CONAN_LIB_FOLDER ${{ inputs.install-path }}
 

.github/workflows/ci.yml

@@ -64,6 +64,8 @@ jobs:
         uses: dtolnay/rust-toolchain@stable
         with:
           components: rustfmt, clippy
+      # This step is not required, but speeds up the build by caching the tket-c-api library
+      # The alternative is to install conan and remove the `TKET_C_API_PATH` env var
       - name: Install tket-c-api library
         uses: ./.github/actions/tket-c-api
         with:
@@ -169,6 +171,8 @@ jobs:
         uses: KyleMayes/install-llvm-action@v2
         with:
           version: ${{ env.LLVM_VERSION }}
+      # This step is not required, but speeds up the build by caching the tket-c-api library
+      # The alternative is to install conan and remove the `TKET_C_API_PATH` env var
       - name: Install tket-c-api library
         uses: ./.github/actions/tket-c-api
         with:
@@ -201,6 +205,8 @@ jobs:
         uses: KyleMayes/install-llvm-action@v2
         with:
           version: ${{ env.LLVM_VERSION }}
+      # This step is not required, but speeds up the build by caching the tket-c-api library
+      # The alternative is to install conan and remove the `TKET_C_API_PATH` env var
       - name: Install tket-c-api library
         uses: ./.github/actions/tket-c-api
         with:
@@ -235,6 +241,8 @@ jobs:
         uses: KyleMayes/install-llvm-action@v2
         with:
           version: ${{ env.LLVM_VERSION }}
+      # This step is not required, but speeds up the build by caching the tket-c-api library
+      # The alternative is to install conan and remove the `TKET_C_API_PATH` env var
       - name: Install tket-c-api library
         uses: ./.github/actions/tket-c-api
         with:

DEVELOPMENT.md

@@ -24,13 +24,6 @@ devenv shell
 All the required dependencies should be available. You can automate loading the
 shell by setting up [direnv](https://devenv.sh/automatic-shell-activation/).
 
-<!-- TODO: Remove once the pre-compiled binaries are available. -->
-Currently you will need to compile the tket C API manually. To do this, run:
-```bash
-just setup-tket-c-api
-```
-This step will be removed in the future, once the pre-compiled binaries are available.
-
 ### Manual setup
 
 To setup the environment manually you will need:

justfile

@@ -4,15 +4,10 @@ help:
 
 # Prepare the environment for development, installing all the dependencies and
 # setting up the pre-commit hooks.
-setup: setup-tket-c-api
+setup:
     uv sync
     [[ -n "${TKET_JUST_INHIBIT_GIT_HOOKS:-}" ]] || uv run pre-commit install -t pre-commit
 
-# Configure the conan cache for tket-c-api.
-setup-tket-c-api:
-    uv run conan remote add -f tket-libs https://quantinuumsw.jfrog.io/artifactory/api/conan/tket1-libs --index 0
-    cd tket1-passes/tket-c-api && uv run conan create . --build=missing
-
 # Run the pre-commit checks.
 check:
     uv run pre-commit run --all-files

tket1-passes/README.md

@@ -7,26 +7,21 @@ API.
 
 ## Building instructions
 
-Building `tket1-passes` is done using `conan >= 2.0`. After installing `conan`,
-(`pip install conan` or use `pipx`), you must set up `conan` to use the
-artifactory containing the tket package:
-
-```
-conan remote add tket-libs https://quantinuumsw.jfrog.io/artifactory/api/conan/tket1-libs --index 0
-```
-
-For the time being, one extra step is required to export `tket-c-api` to the conan cache:
-
-```
-cd tket-c-api && conan create . --build=missing"
-```
-
-That's it! You can now build the library using `cargo build`.
+Building `tket1-passes` is done using `conan >= 2.0`. This will be installed
+automatically by `uv` if using the build tools `just` or `uv` (recommended; see
+[DEVELOPMENT.md](../DEVELOPMENT.md) for more detailed instructions). If you wish
+to run `cargo build` directly, make sure that `conan` is installed and available
+in your `PATH`.
 
 If conan is unable to fetch all dependencies as pre-compiled binaries, you will
 also need standard C++ tooling to compile the dependencies (i.e. a reasonably
 recent version of cmake and a C++ compiler).
 
+You can also eschew using conan altogether by setting the `TKET_C_API_PATH`
+environment variable to point to a pre-compiled version of the `tket-c-api`
+library. Note that this must be a dynamic library (the pre-built binaries on
+conan on the other hand are static libraries).
+
 ## Currently supported TKET1 features
 
 This library is currently limited to legacy TKET passes (a small subset of them, in fact).

tket1-passes/build.rs

@@ -4,16 +4,9 @@
 
 use std::env;
 use std::path::{Path, PathBuf};
+use std::process::Command;
 
-fn is_macos() -> bool {
-    let target = env::var("TARGET").unwrap();
-    target.contains("apple")
-}
-
-fn is_windows() -> bool {
-    let target = env::var("TARGET").unwrap();
-    target.contains("windows")
-}
+const CONAN_REMOTE: &str = "https://quantinuumsw.jfrog.io/artifactory/api/conan/tket1-libs";
 
 fn main() {
     // // Configure when to rerun the build script
@@ -23,20 +16,43 @@ fn main() {
 
     let custom_tket_path = env::var("TKET_C_API_PATH").ok().map(PathBuf::from);
 
+    let target = SupportedPlatform::from_target_str(&env::var("TARGET").unwrap());
+
     let header_path = if let Some(path) = custom_tket_path {
-        cargo_set_custom_lib_path(&path.join("lib"));
+        cargo_set_custom_lib_path(&path.join("lib"), target);
         path.join("include").join("tket-c-api.h")
     } else {
         // Get dependencies from conan
-        let conan_install = conan2::ConanInstall::new()
-            .build("missing")
-            .detect_profile()
-            .run()
-            .parse();
-        conan_install.emit();
-
-        // Get header path
+
+        // 1. Add the conan remote to get the tket-c-api source and binaries
+        add_conan_remote_if_missing(CONAN_REMOTE);
+
+        // 2. Select one of the pre-built conan profiles if possible (fallback to default)
+        let profile_name = target
+            .map(|t| t.get_prebuilt_conan_profile())
+            .unwrap_or_else(|| {
+                println!("cargo:warning=Unrecognized platform. Defaulting to default conan profile and building from source.");
+                "default"
+            });
+        let profile_path = Path::new("./conan-profiles").join(profile_name);
+        println!("Using conan profile: {}", profile_path.display());
+
+        // 3. Prepare the conan install command
+        let mut conan_install = conan2::ConanInstall::new();
         conan_install
+            .build_type("Release")
+            .profile(profile_path.to_str().unwrap());
+
+        if profile_name == "default" {
+            conan_install.detect_profile().build("missing");
+        }
+
+        // 4. Run the conan install command and point cargo to the correct install paths
+        let cargo_instructions = conan_install.run().parse();
+        cargo_instructions.emit();
+
+        // 5. Get header path for bindgen
+        cargo_instructions
             .include_paths()
             .into_iter()
             .map(|incl_path| incl_path.join("tket-c-api.h"))
@@ -51,7 +67,7 @@ fn main() {
     );
 
     // Link in standard C++ library.
-    if is_macos() {
+    if target.is_some_and(|t| t.is_macos()) {
         println!("cargo:rustc-link-lib=c++");
     } else {
         println!("cargo:rustc-link-lib=stdc++");
@@ -70,10 +86,68 @@ fn main() {
         .expect("Couldn't write bindings!");
 }
 
-fn cargo_set_custom_lib_path(search_path: &Path) {
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+enum SupportedPlatform {
+    MacOsX86,
+    MacOsArm,
+    WindowsX86,
+    LinusX86,
+}
+
+impl SupportedPlatform {
+    fn from_target_str(target: &str) -> Option<Self> {
+        if target.contains("apple") && target.contains("x86") {
+            Some(SupportedPlatform::MacOsX86)
+        } else if target.contains("apple") && target.contains("aarch64") {
+            Some(SupportedPlatform::MacOsArm)
+        } else if target.contains("windows") && target.contains("x86") {
+            Some(SupportedPlatform::WindowsX86)
+        } else if target.contains("linux") && target.contains("x86") {
+            Some(SupportedPlatform::LinusX86)
+        } else {
+            None
+        }
+    }
+
+    fn is_macos(&self) -> bool {
+        matches!(
+            self,
+            SupportedPlatform::MacOsX86 | SupportedPlatform::MacOsArm
+        )
+    }
+
+    fn get_prebuilt_conan_profile(&self) -> &'static str {
+        // Corresponds to profiles which have pre-built binaries in the tket-libs conan remote
+        // See ./conan-profiles/README.md for more details
+        match self {
+            SupportedPlatform::MacOsX86 => "macos-13",
+            SupportedPlatform::MacOsArm => "macos-15",
+            SupportedPlatform::WindowsX86 => "windows-2025",
+            SupportedPlatform::LinusX86 => "linux-x86_64-gcc14",
+        }
+    }
+}
+
+fn add_conan_remote_if_missing(conan_remote: &str) {
+    let check_exists = Command::new("conan")
+        .args(["remote", "list", "-fjson"])
+        .output()
+        .unwrap();
+
+    let stdout_str = String::from_utf8_lossy(&check_exists.stdout);
+    if !stdout_str.contains(conan_remote) {
+        println!("Adding conan remote: {conan_remote}");
+        Command::new("conan")
+            .args(["remote", "add", "tket-libs", conan_remote, "--index", "0"])
+            .output()
+            .unwrap();
+    }
+}
+
+fn cargo_set_custom_lib_path(search_path: &Path, target: Option<SupportedPlatform>) {
     println!("cargo:rustc-link-search={}", search_path.display());
 
-    let lib_name = if is_windows() {
+    let lib_name = if target.is_some_and(|t| t == SupportedPlatform::WindowsX86) {
         "libtket-c-api"
     } else {
         "tket-c-api"

tket1-passes/conan-profiles/README.md

@@ -0,0 +1,5 @@
+This directory lists the conan profiles for which pre-built tket-c-api binaries
+are available in the tket-libs conan remote.
+The build script in `../build.rs` will try to use one of these profiles if possible.
+
+They have been copied over from the [tket repository](https://github.com/CQCL/tket/tree/fed6b1c15dfa12df5520578b5fa852210187727e/conan-profiles).

tket1-passes/conan-profiles/linux-x86_64-gcc13

@@ -0,0 +1,8 @@
+[settings]
+arch=x86_64
+build_type=Release
+compiler=gcc
+compiler.cppstd=gnu17
+compiler.libcxx=libstdc++11
+compiler.version=13
+os=Linux

tket1-passes/conan-profiles/macos-13

@@ -0,0 +1,8 @@
+[settings]
+arch=x86_64
+build_type=Release
+compiler=apple-clang
+compiler.cppstd=gnu17
+compiler.libcxx=libc++
+compiler.version=15
+os=Macos

tket1-passes/conan-profiles/macos-15

@@ -0,0 +1,8 @@
+[settings]
+arch=armv8
+build_type=Release
+compiler=apple-clang
+compiler.cppstd=gnu17
+compiler.libcxx=libc++
+compiler.version=16
+os=Macos