mzdata 0.63.4

A library to read mass spectrometry data formats and a data model for mass spectra
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
131
132
133

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

from typing import Tuple, Dict, Set, List

import fastobo
from fastobo.term import (
    TermFrame,
    IsAClause,
    NameClause,
    DefClause,
)

from fastobo.doc import OboDoc

from fastobo.id import PrefixedIdent

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

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

type_pat = re.compile(
    "([A-Za-z]+)=(xsd:(%s+))"
    % "|".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):
                if 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
    else:
        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():
    cv: OboDoc = fastobo.load(gzip.open("./cv/psi-ms.obo.gz"))
    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()