shilp-sdk 0.12.2

Rust SDK for the Shilp Vector Database API
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
121
122

use crate::client::Client;
use crate::error::Result;
use crate::models::{
    DebugDistanceResponse, DebugLevelsResponse, DebugNodeInfoResponse,
    DebugNodesAtLevelResponse, DebugReferenceNodeResponse,
};
use std::collections::HashMap;

impl Client {
    /// Gets the distance of a node in a collection for debug purposes
    pub async fn get_collection_distance(
        &self,
        collection_name: &str,
        field: &str,
        node_id: i32,
        text: &str,
    ) -> Result<DebugDistanceResponse> {
        let path = format!(
            "/api/collections/v1/debug/{}/{}/distance/{}",
            collection_name, field, node_id
        );
        let mut params = HashMap::new();
        params.insert("text".to_string(), text.to_string());

        self.do_request::<DebugDistanceResponse, ()>(
            reqwest::Method::GET,
            &path,
            None,
            Some(&params),
        )
        .await
    }

    /// Gets node info of a collection for debug purposes
    pub async fn get_collection_node_info(
        &self,
        collection_name: &str,
        field: &str,
        node_id: i32,
    ) -> Result<DebugNodeInfoResponse> {
        let path = format!(
            "/api/collections/v1/debug/{}/{}/nodes/{}",
            collection_name, field, node_id
        );
        self.do_request::<DebugNodeInfoResponse, ()>(reqwest::Method::GET, &path, None, None)
            .await
    }

    /// Gets node neighbors at a level of a collection for debug purposes
    pub async fn get_collection_node_neighbors_at_level(
        &self,
        collection_name: &str,
        field: &str,
        node_id: i32,
        level: i32,
        limit: Option<i32>,
        offset: Option<i32>,
    ) -> Result<DebugNodeInfoResponse> {
        let path = format!(
            "/api/collections/v1/debug/{}/{}/nodes/{}/neighbors/{}",
            collection_name, field, node_id, level
        );

        let mut params = HashMap::new();
        if let Some(l) = limit {
            params.insert("limit".to_string(), l.to_string());
        }
        if let Some(o) = offset {
            params.insert("offset".to_string(), o.to_string());
        }

        self.do_request::<DebugNodeInfoResponse, ()>(
            reqwest::Method::GET,
            &path,
            None,
            if params.is_empty() {
                None
            } else {
                Some(&params)
            },
        )
        .await
    }

    /// Gets levels of a collection for debug purposes
    pub async fn get_collection_levels(
        &self,
        collection_name: &str,
    ) -> Result<DebugLevelsResponse> {
        let path = format!("/api/collections/v1/debug/{}/levels", collection_name);
        self.do_request::<DebugLevelsResponse, ()>(reqwest::Method::GET, &path, None, None)
            .await
    }

    /// Gets nodes at a level of a collection for debug purposes
    pub async fn get_collection_nodes_at_level(
        &self,
        collection_name: &str,
        level: i32,
    ) -> Result<DebugNodesAtLevelResponse> {
        let path = format!(
            "/api/collections/v1/debug/{}/levels/{}",
            collection_name, level
        );
        self.do_request::<DebugNodesAtLevelResponse, ()>(reqwest::Method::GET, &path, None, None)
            .await
    }

    /// Gets node by reference node ID of a collection for debug purposes
    pub async fn get_collection_node_by_reference_node_id(
        &self,
        collection_name: &str,
        node_id: i32,
    ) -> Result<DebugReferenceNodeResponse> {
        let path = format!(
            "/api/collections/v1/debug/{}/nodes/reference_node/{}",
            collection_name, node_id
        );
        self.do_request::<DebugReferenceNodeResponse, ()>(reqwest::Method::GET, &path, None, None)
            .await
    }
}