clade 0.1.3

A tool for phlyo tree, a phylogenetic tree construction software.
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

use std::collections::HashMap;
use std::fs::File;
use std::io::{self, BufRead, BufReader};
use std::path::PathBuf;

pub fn load(
    taxo_path: &PathBuf,
) -> io::Result<(Vec<String>, Vec<usize>, Vec<String>, Vec<String>, Vec<f64>)> {
    let names_path = taxo_path.join("names.dmp");
    let nodes_path = taxo_path.join("nodes.dmp");

    let names_file = File::open(names_path)?;
    let nodes_file = File::open(nodes_path)?;

    let names_reader = BufReader::new(names_file);
    let nodes_reader = BufReader::new(nodes_file);

    let mut taxid_to_index = HashMap::new();
    let mut taxid_vec = Vec::new();
    let mut parent_taxid_vec = Vec::new();
    let mut name_vec = Vec::new();
    let mut rank_vec = Vec::new();
    let mut parent_distances = Vec::new();

    // Read nodes.dmp file
    for (index, line) in nodes_reader.lines().enumerate() {
        let line = line?;
        let parts: Vec<&str> = line.split("\t|\t").collect();
        if parts.len() >= 3 {
            let taxid = parts[0].to_string();
            let parent_taxid = parts[1].to_string();
            let rank = parts[2].to_string();

            taxid_to_index.insert(taxid.clone(), index);
            taxid_vec.push(taxid);
            parent_taxid_vec.push(parent_taxid);
            rank_vec.push(rank);
            name_vec.push(String::new()); // Initialize with empty string
            parent_distances.push(1.0); // Default distance
        }
    }

    // Read names.dmp file
    for line in names_reader.lines() {
        let line = line?;
        let parts: Vec<&str> = line.split('\t').collect();
        if parts.len() >= 7 && parts[6] == "scientific name" {
            let taxid = parts[0].to_string();
            if let Some(&index) = taxid_to_index.get(&taxid) {
                name_vec[index] = parts[2].to_string();
            }
        }
    }

    // Convert parent_taxid_vec to parentid_vec using indices
    let parentid_vec: Vec<usize> = parent_taxid_vec
        .iter()
        .map(|parent_taxid| taxid_to_index.get(parent_taxid).cloned().unwrap_or(0))
        .collect();

    Ok((
        taxid_vec,
        parentid_vec,
        name_vec,
        rank_vec,
        parent_distances,
    ))
}

pub fn print_taxonomy_summary(taxo_path: &PathBuf) -> io::Result<()> {
    let (taxid_vec, parentid_vec, name_vec, rank_vec, parent_distances) = load(taxo_path)?;

    println!("Generated taxonomy summary:");
    println!("Number of taxa: {}", taxid_vec.len());
    println!("First 5 entries:");
    for i in 0..5.min(taxid_vec.len()) {
        println!(
            "Index: {}, TaxID: {}, ParentIndex: {}, Name: {}, Rank: {}, ParentDistance: {}",
            i, taxid_vec[i], parentid_vec[i], name_vec[i], rank_vec[i], parent_distances[i]
        );
    }

    Ok(())
}