Restructure

extern/backend/Cargo.toml

@@ -20,4 +20,4 @@ anyhow = { version = "1.0.95" }
 sha2 = { version = "0.10.8" }
 uuid = { version = "1.15.1", features = ["v4"] }
 bincode = { version = "1.1.3" }
-tokio = { version = "1.43.0" }
+tokio = { version = "1.43.0", features = ["sync"] }

extern/backend/nodes/bundled_node/meta.toml

@@ -0,0 +1,5 @@
+name = "bundled_node"
+description = "A bundled node"
+author = "Author"
+date = "2025-03-05T19:02:06.992970322Z"
+impls = [[{ deps = [] }, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"]]

extern/backend/nodes/complex_bundled_node/meta.toml

@@ -0,0 +1,5 @@
+name = "complex_bundled_node"
+description = "A complex bundled node"
+author = "Author"
+date = "2025-03-05T19:02:06.992988239Z"
+impls = [[{ deps = [{ name = "serde", versions = ["1.0"], lib = true }] }, "347d4e7d76b463a7b8415486415c698bf2c792ee6384f96eca96e1d45a2f3986"]]

extern/backend/nodes/test_code_node/meta.toml

@@ -0,0 +1,5 @@
+name = "test_code_node"
+description = "A simple code node"
+author = "Author"
+date = "2025-03-05T17:47:07.471655003Z"
+impls = [[{ deps = [] }, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"]]

extern/backend/src/lib.rs

@@ -1,3 +1,2 @@
-pub mod compiler;
-pub mod nms;
-pub mod utils;
+pub mod modules;
+pub use modules::*;

extern/backend/src/modules.rs

@@ -0,0 +1,3 @@
+pub mod compiler;
+pub mod nms;
+pub mod utils;

extern/backend/src/nms/create.rs → extern/backend/src/modules/nms/create.rs

@@ -1,5 +1,5 @@
 use crate::nms::check_name;
-use crate::utils::*;
+use crate::utils::prelude::{save::*, *};
 use anyhow::Result;
 use std::fs::{create_dir, File};
 use std::io::Write;

extern/backend/src/modules/utils.rs

@@ -0,0 +1,29 @@
+pub mod container;
+pub mod context;
+pub mod date;
+pub mod dtype;
+pub mod environment;
+pub mod metadata;
+pub mod node;
+pub mod param;
+pub mod save_node;
+pub mod save_param;
+pub mod search;
+
+pub mod prelude {
+    pub use super::container::*;
+    pub use super::context::*;
+    pub use super::date::*;
+    pub use super::dtype::*;
+    pub use super::environment::*;
+    pub use super::metadata::*;
+    pub use super::node::*;
+    pub use super::param::*;
+    pub mod save {
+        pub use super::super::save_node::*;
+        pub use super::super::save_param::*;
+    }
+    pub mod search {
+        pub use super::super::search::*;
+    }
+}

extern/backend/src/modules/utils/container.rs

@@ -0,0 +1,31 @@
+use super::prelude::*;
+
+// -------------------- CONTAINER -------------------- //
+#[derive(Clone, PartialEq)]
+pub struct Container<T> {
+    pub tree: Vec<StrongContext<T>>,
+}
+
+impl<T> Container<T> {
+    pub fn new() -> Self {
+        Self { tree: Vec::new() }
+    }
+    pub fn push(&mut self, item: T) {
+        self.push_context(StrongContext::from(item))
+    }
+    pub fn push_context(&mut self, ctx: StrongContext<T>) {
+        self.tree.push(ctx);
+    }
+}
+
+impl<T> Default for Container<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+// -------------------- NODE CONTAINER -------------------- //
+pub type NodeContainer = Container<Node>;
+
+// -------------------- PARAM CONTAINER -------------------- //
+pub type ParamContainer = Container<Param>;

extern/backend/src/modules/utils/context.rs

@@ -0,0 +1,69 @@
+use derive_new::new;
+use std::sync::{Arc, Weak};
+use tokio::sync::Mutex;
+// -------------------- STRONG CONTEXT -------------------- //
+#[derive(new, Clone)]
+pub struct StrongContext<T> {
+    pub context: Arc<Mutex<T>>,
+}
+
+impl<T> StrongContext<T> {
+    pub fn downgrade(self) -> WeakContext<T> {
+        WeakContext::from(self)
+    }
+}
+
+impl<T> PartialEq for StrongContext<T>
+where
+    T: PartialEq,
+{
+    fn eq(&self, other: &Self) -> bool {
+        let self_data = self.context.blocking_lock();
+        let other_data = other.context.blocking_lock();
+        *self_data == *other_data
+    }
+}
+
+impl<T> From<T> for StrongContext<T> {
+    fn from(t: T) -> Self {
+        Self::new(Arc::new(Mutex::new(t)))
+    }
+}
+
+impl<T> From<WeakContext<T>> for Option<StrongContext<T>> {
+    fn from(weak: WeakContext<T>) -> Option<StrongContext<T>> {
+        if let Some(c) = weak.context.upgrade() {
+            return Some(StrongContext::new(c));
+        }
+        None
+    }
+}
+
+// -------------------- WEAK CONTEXT -------------------- //
+#[derive(new, Clone)]
+pub struct WeakContext<T> {
+    pub context: Weak<Mutex<T>>,
+}
+impl<T> WeakContext<T> {
+    pub fn upgrade(self) -> Option<StrongContext<T>> {
+        Option::<StrongContext<T>>::from(self)
+    }
+}
+impl<T> PartialEq for WeakContext<T>
+where
+    T: PartialEq + Clone,
+{
+    fn eq(&self, other: &Self) -> bool {
+        if let Some(self_ctx) = self.clone().upgrade() {
+            if let Some(other_ctx) = other.clone().upgrade() {
+                return self_ctx == other_ctx;
+            }
+        }
+        false
+    }
+}
+impl<T> From<StrongContext<T>> for WeakContext<T> {
+    fn from(other: StrongContext<T>) -> Self {
+        Self::new(Arc::downgrade(&other.context))
+    }
+}

extern/backend/src/modules/utils/date.rs

@@ -0,0 +1,3 @@
+use chrono::prelude::*;
+// -------------------- DATE -------------------- //
+pub type Date = DateTime<Utc>;

extern/backend/src/modules/utils/dtype.rs

@@ -0,0 +1,17 @@
+use serde::{Deserialize, Serialize};
+// -------------------- DTYPE -------------------- //
+#[derive(Clone, PartialEq, Serialize, Deserialize)]
+pub enum DType {
+    Tensor {
+        dtype: Box<DType>,
+        shape: Vec<String>,
+    },
+    I16,
+    I32,
+    I64,
+    F32,
+    F64,
+    Bool,
+    String,
+    Void,
+}

extern/backend/src/modules/utils/environment.rs

@@ -0,0 +1,76 @@
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::collections::HashMap;
+// -------------------- ENVIRONEMENT -------------------- //
+#[derive(Clone, PartialEq, Serialize, Deserialize)]
+pub struct Dependency {
+    pub name: String,
+    pub versions: Vec<String>,
+    pub lib: bool,
+}
+
+#[derive(Clone, PartialEq, Serialize, Deserialize)]
+pub struct Environment {
+    pub deps: Vec<Dependency>,
+}
+
+impl Environment {
+    pub fn hash(&self) -> String {
+        let mut hasher = Sha256::new();
+        let mut deps_sorted = self.deps.clone();
+        deps_sorted.sort_by(|a, b| a.name.cmp(&b.name));
+
+        for dep in &deps_sorted {
+            hasher.update(dep.name.as_bytes());
+            hasher.update(dep.lib.to_string().as_bytes());
+            let mut versions_sorted = dep.versions.clone();
+            versions_sorted.sort();
+            for version in versions_sorted {
+                hasher.update(version.as_bytes());
+            }
+        }
+
+        format!("{:x}", hasher.finalize())
+    }
+
+    pub fn merge(&self, other: &Environment) -> Result<Environment, String> {
+        let mut merged_deps: HashMap<(String, bool), Vec<String>> = HashMap::new();
+
+        for dep in &self.deps {
+            merged_deps.insert((dep.name.clone(), dep.lib), dep.versions.clone());
+        }
+
+        for dep in &other.deps {
+            let key = (dep.name.clone(), dep.lib);
+            if let Some(existing_versions) = merged_deps.get(&key) {
+                let common_versions: Vec<String> = existing_versions
+                    .iter()
+                    .filter(|v| dep.versions.contains(v))
+                    .cloned()
+                    .collect();
+                if common_versions.is_empty() {
+                    return Err(format!(
+                        "No compatible versions for dependency: {}",
+                        dep.name
+                    ));
+                }
+                merged_deps.insert(key, common_versions);
+            } else {
+                merged_deps.insert(key, dep.versions.clone());
+            }
+        }
+
+        let merged_env = Environment {
+            deps: merged_deps
+                .into_iter()
+                .map(|((name, lib), versions)| Dependency {
+                    name,
+                    versions,
+                    lib,
+                })
+                .collect(),
+        };
+
+        Ok(merged_env)
+    }
+}

extern/backend/src/modules/utils/metadata.rs

@@ -0,0 +1,28 @@
+use super::prelude::*;
+use derive_builder::Builder;
+use serde::{Deserialize, Serialize};
+// -------------------- METADATA -------------------- //
+#[derive(Builder, Serialize, Deserialize)]
+pub struct Metadata {
+    pub name: String,
+    pub description: String,
+    pub author: String,
+    pub date: Date,
+    pub impls: Vec<(Environment, String)>,
+}
+
+impl From<Node> for Metadata {
+    fn from(node: Node) -> Self {
+        MetadataBuilder::default()
+            .name(node.name.clone())
+            .description(node.description.clone())
+            .author(node.author.clone())
+            .date(node.date)
+            .impls(vec![(
+                node.clone().get_full_env().clone(),
+                node.clone().get_full_env().hash(),
+            )])
+            .build()
+            .expect("Internal error")
+    }
+}