mzdata 0.66.2

A library to read mass spectrometry data formats and a data model for mass spectra
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
123
124
125
126
127
128
129
130

import gzip
import io
import itertools
import json
import re
import sys

import fastobo
from fastobo.doc import OboDoc
from fastobo.id import PrefixedIdent
from fastobo.term import (
    DefClause,
    IsAClause,
    NameClause,
    TermFrame,
)

ROOT_TERM = PrefixedIdent("MS", "1000767")

segment_pattern = re.compile(r"(_[a-zA-Z])")

type_pat = re.compile(
    "([A-Za-z]+)=(xsd:({}+))".format("|".join({"IDREF", "long", "nonNegativeInteger", "positiveInteger", "string"}))
)

xsd_to_regex = {
    "IDREF": r"\S+",
    "long": r"-?\d+",
    "nonNegativeInteger": r"\d+",
    "positiveInteger": r"\d+",
    "string": r"\S+",
}


def collect_components(
    cv: OboDoc, base_term: PrefixedIdent
) -> tuple[set[PrefixedIdent], dict[PrefixedIdent, TermFrame]]:
    term: TermFrame
    id_to_clause = {}
    component_ids = {base_term}
    # Make multiple passes
    for term in itertools.chain(cv, cv):
        id_to_clause[term.id] = term
        for clause in term:
            if isinstance(clause, IsAClause) and clause.term in component_ids:
                component_ids.add(term.id)
    return component_ids, id_to_clause


def format_name(match: re.Match) -> str:
    return match.group(1)[-1].upper()


def find_name(term: TermFrame):
    for clause in term:
        if isinstance(clause, NameClause):
            name = str(clause.name)
            return name
    raise LookupError(f"Term name not found for {term.id!s}")


def make_entry_for(term: TermFrame):
    name = None
    parents = []
    descr = ""
    for clause in term:
        if isinstance(clause, NameClause):
            name = str(clause.name)
        if isinstance(clause, IsAClause):
            parents.append(str(clause.term))
        if isinstance(clause, DefClause):
            descr = str(clause.definition)
            try:
                descr = descr.split("defined by ")[1].rstrip(".")
                descr = type_pat.sub(
                    lambda x: (
                        f"{x.group(1)}=(?<{x.group(1)}>{xsd_to_regex[x.group(3)]})"
                    ),
                    descr,
                )
            except IndexError:
                descr = "(.+)"

    vname = name
    if "-" in vname:
        vname = vname.replace("-", "_")
    if ":" in vname:
        vname = vname.replace(":", "_")
    if "/" in vname:
        vname = vname.replace("/", "_")
    if "+" in vname:
        vname = vname.replace("+", "plus")
    if "!" in vname:
        vname = vname.replace("!", "_")

    vname = segment_pattern.sub(format_name, vname.replace(" ", "_"))
    vname = vname[0].upper() + vname[1:]

    if vname[0].isdigit():
        vname = "_" + vname

    return f"""
    #[term(cv=MS, accession={term.id.local}, name="{name}", flags={{r"{descr}"}}, parents={{{json.dumps(parents)}}})]
    #[doc = r"{name} - `{descr}`"]
    {vname},"""


def generate_term_enum(terms: list[TermFrame], type_name: str):
    buffer = io.StringIO()
    buffer.write("pub enum $Term {".replace("$", type_name))
    for term in terms:
        buffer.write(make_entry_for(term))
    buffer.write("\n}")
    return buffer.getvalue()


def main():
    with gzip.open("./cv/psi-ms.obo.gz") as handle:
        cv: OboDoc = fastobo.load(handle)
        term_ids, id_to_clause = collect_components(cv, ROOT_TERM)
        t = find_name(id_to_clause[ROOT_TERM])
        type_name = t.title().replace(" ", "")

        term_specs = list(map(id_to_clause.get, sorted(term_ids)))
        text = generate_term_enum(term_specs, type_name).encode("utf8")
        sys.stdout.buffer.write(text)


if __name__ == "__main__":
    main()