xz-knowledge-graph 0.2.0

Structured knowledge graph storage engine with graph traversal
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

use std::collections::HashMap;

use serde::{Deserialize, Serialize};

use super::attribute::AttributeValue;

/// Entity type with hierarchical classification.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum EntityType {
    Person,
    Location,
    Item,
    Organization,
    Concept,
    Resource,
    Ability,
    Event(String),
    Custom { category: String, label: String },
}

impl EntityType {
    pub fn category(&self) -> &str {
        match self {
            Self::Person => "Person",
            Self::Location => "Location",
            Self::Item => "Item",
            Self::Organization => "Organization",
            Self::Concept => "Concept",
            Self::Resource => "Resource",
            Self::Ability => "Ability",
            Self::Event(_) => "Event",
            Self::Custom { category, .. } => category,
        }
    }

    pub fn as_str(&self) -> String {
        match self {
            Self::Person => "Person".into(),
            Self::Location => "Location".into(),
            Self::Item => "Item".into(),
            Self::Organization => "Organization".into(),
            Self::Concept => "Concept".into(),
            Self::Resource => "Resource".into(),
            Self::Ability => "Ability".into(),
            Self::Event(s) => format!("Event:{}", s),
            Self::Custom { category, label } => format!("{}:{}", category, label),
        }
    }

    pub fn from_str(s: &str) -> Self {
        match s {
            "Person" => Self::Person,
            "Location" => Self::Location,
            "Item" => Self::Item,
            "Organization" => Self::Organization,
            "Concept" => Self::Concept,
            "Resource" => Self::Resource,
            "Ability" => Self::Ability,
            other => {
                if let Some(rest) = other.strip_prefix("Event:") {
                    Self::Event(rest.to_string())
                } else if let Some((cat, label)) = other.split_once(':') {
                    Self::Custom {
                        category: cat.to_string(),
                        label: label.to_string(),
                    }
                } else {
                    Self::Custom {
                        category: "Other".into(),
                        label: other.to_string(),
                    }
                }
            }
        }
    }
}

/// Knowledge graph entity.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Entity {
    pub id: String,
    pub name: String,
    pub aliases: Vec<String>,
    pub entity_type: EntityType,
    pub attributes: HashMap<String, AttributeValue>,
    pub description: Option<String>,
    pub created_at: u64,
    pub updated_at: u64,
    pub version: u64,
    pub source: Option<String>,
    pub tags: Vec<String>,
}