uni-algo 0.1.5

Graph algorithms for Uni - PageRank, Louvain, shortest paths, and more
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

// SPDX-License-Identifier: Apache-2.0
// Copyright 2024-2026 Dragonscale Team

//! uni.algo.randomWalk procedure implementation.

use crate::algo::algorithms::{Algorithm, RandomWalk, RandomWalkConfig};
use crate::algo::procedure_template::{GenericAlgoProcedure, GraphAlgoAdapter};
use crate::algo::procedures::{AlgoResultRow, ValueType};
use anyhow::{Result, anyhow};
use serde_json::{Value, json};
use uni_common::core::id::Vid;

pub struct RandomWalkAdapter;

impl GraphAlgoAdapter for RandomWalkAdapter {
    const NAME: &'static str = "uni.algo.randomWalk";
    type Algo = RandomWalk;

    fn specific_args() -> Vec<(&'static str, ValueType, Option<Value>)> {
        vec![
            ("walkLength", ValueType::Int, Some(json!(5))),
            ("walksPerNode", ValueType::Int, Some(json!(1))),
            ("startNodes", ValueType::List, Some(Value::Null)),
        ]
    }

    fn yields() -> Vec<(&'static str, ValueType)> {
        vec![("path", ValueType::List)]
    }

    fn to_config(args: Vec<Value>) -> RandomWalkConfig {
        let walk_length = args[0].as_u64().unwrap_or(5) as usize;
        let walks_per_node = args[1].as_u64().unwrap_or(1) as usize;

        let start_nodes = if args[2].is_null() {
            Vec::new()
        } else {
            let list = args[2].as_array().unwrap();
            let mut vids = Vec::new();
            for val in list {
                if let Ok(v) = vid_from_value(val) {
                    vids.push(v);
                }
            }
            vids
        };

        RandomWalkConfig {
            walk_length,
            walks_per_node,
            start_nodes,
            return_param: 1.0,
            in_out_param: 1.0,
        }
    }

    fn map_result(result: <Self::Algo as Algorithm>::Result) -> Result<Vec<AlgoResultRow>> {
        Ok(result
            .walks
            .into_iter()
            .map(|walk| {
                let path: Vec<Value> = walk.iter().map(|v| json!(v.as_u64())).collect();
                AlgoResultRow {
                    values: vec![Value::Array(path)],
                }
            })
            .collect())
    }
}

fn vid_from_value(val: &Value) -> Result<Vid> {
    if let Some(s) = val.as_str()
        && let Ok(vid) = s.parse::<Vid>()
    {
        return Ok(vid);
    }
    if let Some(v) = val.as_u64() {
        return Ok(Vid::from(v));
    }
    Err(anyhow!("Invalid Vid format"))
}

pub type RandomWalkProcedure = GenericAlgoProcedure<RandomWalkAdapter>;