Separate build data structs from serializations

build2cmake/src/config/compat.rs

@@ -0,0 +1,39 @@
+use eyre::Result;
+use serde::Deserialize;
+use serde_value::Value;
+
+use super::{v1, v2, v3, Build};
+
+#[derive(Debug)]
+pub enum BuildCompat {
+    V1(v1::Build),
+    V2(v2::Build),
+    V3(v3::Build),
+}
+
+impl<'de> Deserialize<'de> for BuildCompat {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let value = Value::deserialize(deserializer)?;
+
+        v1::Build::deserialize(value.clone())
+            .map(BuildCompat::V1)
+            .or_else(|_| v2::Build::deserialize(value.clone()).map(BuildCompat::V2))
+            .or_else(|_| v3::Build::deserialize(value.clone()).map(BuildCompat::V3))
+            .map_err(serde::de::Error::custom)
+    }
+}
+
+impl TryFrom<BuildCompat> for Build {
+    type Error = eyre::Error;
+
+    fn try_from(compat: BuildCompat) -> Result<Self> {
+        match compat {
+            BuildCompat::V1(v1_build) => v1_build.try_into(),
+            BuildCompat::V2(v2_build) => v2_build.try_into(),
+            BuildCompat::V3(v3_build) => Ok(v3_build.into()),
+        }
+    }
+}

build2cmake/src/config/deps.rs

@@ -0,0 +1,89 @@
+use std::{collections::HashMap, sync::LazyLock};
+
+use eyre::Result;
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+use super::Backend;
+
+pub static PYTHON_DEPENDENCIES: LazyLock<PythonDependencies> =
+    LazyLock::new(|| serde_json::from_str(include_str!("../python_dependencies.json")).unwrap());
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
+#[non_exhaustive]
+#[serde(rename_all = "lowercase")]
+pub enum Dependency {
+    #[serde(rename = "cutlass_2_10")]
+    Cutlass2_10,
+    #[serde(rename = "cutlass_3_5")]
+    Cutlass3_5,
+    #[serde(rename = "cutlass_3_6")]
+    Cutlass3_6,
+    #[serde(rename = "cutlass_3_8")]
+    Cutlass3_8,
+    #[serde(rename = "cutlass_3_9")]
+    Cutlass3_9,
+    #[serde(rename = "cutlass_4_0")]
+    Cutlass4_0,
+    #[serde(rename = "cutlass_sycl")]
+    CutlassSycl,
+    #[serde(rename = "metal-cpp")]
+    MetalCpp,
+    Torch,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct PythonDependencies {
+    general: HashMap<String, PythonDependency>,
+    backends: HashMap<Backend, HashMap<String, PythonDependency>>,
+}
+
+impl PythonDependencies {
+    pub fn get_dependency(&self, dependency: &str) -> Result<&[String], DependencyError> {
+        match self.general.get(dependency) {
+            None => Err(DependencyError::GeneralDependency {
+                dependency: dependency.to_string(),
+            }),
+            Some(dep) => Ok(&dep.python),
+        }
+    }
+
+    pub fn get_backend_dependency(
+        &self,
+        backend: Backend,
+        dependency: &str,
+    ) -> Result<&[String], DependencyError> {
+        let backend_deps = match self.backends.get(&backend) {
+            None => {
+                return Err(DependencyError::Backend {
+                    backend: backend.to_string(),
+                })
+            }
+            Some(backend_deps) => backend_deps,
+        };
+        match backend_deps.get(dependency) {
+            None => Err(DependencyError::Dependency {
+                backend: backend.to_string(),
+                dependency: dependency.to_string(),
+            }),
+            Some(dep) => Ok(&dep.python),
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+struct PythonDependency {
+    nix: Vec<String>,
+    python: Vec<String>,
+}
+
+#[derive(Debug, Error)]
+pub enum DependencyError {
+    #[error("No dependencies are defined for backend: {backend:?}")]
+    Backend { backend: String },
+    #[error("Unknown dependency `{dependency:?}` for backend `{backend:?}`")]
+    Dependency { backend: String, dependency: String },
+    #[error("Unknown dependency: `{dependency:?}`")]
+    GeneralDependency { dependency: String },
+}