kunquant_rs 0.1.1

Rust bindings for KunQuant financial factor computation library
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use kunquant_rs::{Executor, Library, Result, StreamContext};
use std::path::Path;

const NUM_STOCKS: usize = 8; // Must be multiple of 8

#[test]
fn test_stream_creation_only() -> Result<()> {
    // Check if streaming test library exists
    let lib_path = "test_libs/simple_stream_lib.so";
    if !Path::new(lib_path).exists() {
        panic!(
            "Streaming test library not found. Please run 'python generate_test_factor.py' first"
        );
    }

    // Create executor and load library
    let executor = Executor::single_thread()?;
    let library = Library::load(lib_path)?;
    let module = library.get_module("simple_stream_test")?;

    // Just try to create stream context
    let _stream = StreamContext::new(&executor, &module, NUM_STOCKS)?;

    println!("✓ Stream context created successfully!");
    Ok(())
}

#[test]
fn test_stream_buffer_handles() -> Result<()> {
    let lib_path = "test_libs/simple_stream_lib.so";
    if !Path::new(lib_path).exists() {
        panic!(
            "Streaming test library not found. Please run 'python generate_test_factor.py' first"
        );
    }

    let executor = Executor::single_thread()?;
    let library = Library::load(lib_path)?;
    let module = library.get_module("simple_stream_test")?;

    let mut stream = StreamContext::new(&executor, &module, NUM_STOCKS)?;

    // Try to get buffer handles (only the ones actually used by the factor)
    let input_names = ["close", "open", "high", "low"];
    let output_names = ["simple_stream"];

    println!("Testing input buffer handles:");
    for name in &input_names {
        match stream.get_buffer_handle(name) {
            Ok(handle) => println!("  {} -> handle {}", name, handle),
            Err(e) => println!("  {} -> ERROR: {:?}", name, e),
        }
    }

    println!("Testing output buffer handles:");
    for name in &output_names {
        match stream.get_buffer_handle(name) {
            Ok(handle) => println!("  {} -> handle {}", name, handle),
            Err(e) => println!("  {} -> ERROR: {:?}", name, e),
        }
    }

    println!("✓ Buffer handle test completed!");
    Ok(())
}

#[test]
fn test_stream_single_step() -> Result<()> {
    let lib_path = "test_libs/simple_stream_lib.so";
    if !Path::new(lib_path).exists() {
        panic!(
            "Streaming test library not found. Please run 'python generate_test_factor.py' first"
        );
    }

    let executor = Executor::single_thread()?;
    let library = Library::load(lib_path)?;
    let module = library.get_module("simple_stream_test")?;

    let mut stream = StreamContext::new(&executor, &module, NUM_STOCKS)?;

    // Create simple test data
    let close_data = vec![100.0, 101.0, 102.0, 103.0, 104.0, 105.0, 106.0, 107.0];
    let open_data = vec![99.0, 100.0, 101.0, 102.0, 103.0, 104.0, 105.0, 106.0];
    let high_data = vec![101.0, 102.0, 103.0, 104.0, 105.0, 106.0, 107.0, 108.0];
    let low_data = vec![98.0, 99.0, 100.0, 101.0, 102.0, 103.0, 104.0, 105.0];
    println!("Pushing input data...");

    // Push data step by step with error checking (only the required inputs)
    println!("  Pushing close data...");
    stream.push_data("close", &close_data)?;

    println!("  Pushing open data...");
    stream.push_data("open", &open_data)?;

    println!("  Pushing high data...");
    stream.push_data("high", &high_data)?;

    println!("  Pushing low data...");
    stream.push_data("low", &low_data)?;

    println!("Running computation...");
    stream.run()?;

    println!("Getting output data...");
    let output_data = stream.get_current_buffer("simple_stream")?;

    println!("Results:");
    for i in 0..NUM_STOCKS {
        let expected = (close_data[i] - open_data[i]) / (high_data[i] - low_data[i] + 0.001);
        let actual = output_data[i];
        println!(
            "  Stock {}: expected {:.6}, actual {:.6}",
            i, expected, actual
        );
    }

    println!("✓ Single step stream test completed!");
    Ok(())
}