pyobo 0.11.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

pyobo/sources/signor/download.py

@@ -0,0 +1,41 @@
+"""Download utilities for SIGNOR."""
+
+import enum
+
+import pandas as pd
+import requests
+
+from pyobo.utils.path import prefix_directory_join
+
+__all__ = [
+    "DownloadKey",
+    "download_signor",
+    "get_signor_df",
+]
+
+
+class DownloadKey(enum.Enum):
+    """Download key."""
+
+    complex = "Download complex data"
+    family = "Download protein family data"
+    phenotype = "Download phenotype data"
+    stimulus = "Download stimulus data"
+
+
+def download_signor(key: DownloadKey) -> requests.Response:
+    """Download from SIGNOR."""
+    return requests.post(
+        "https://signor.uniroma2.it/download_complexes.php",
+        files={"submit": (None, key.value)},
+    )
+
+
+def get_signor_df(prefix: str, *, version: str, key: DownloadKey, force: bool) -> pd.DataFrame:
+    """Get the appropriate SIGNOR dataframe."""
+    path = prefix_directory_join(prefix, version=version, name=f"{key.name}.csv")
+    if not path.is_file() or force:
+        res = download_signor(key)
+        path.write_text(res.text)
+    df = pd.read_csv(path, sep=";")
+    return df

pyobo/sources/signor/signor_complexes.py

@@ -0,0 +1,105 @@
+"""A source for SIGNOR complexes."""
+
+from collections.abc import Iterable
+
+import pandas as pd
+
+from pyobo import Obo, Reference, Term, default_reference
+from pyobo.sources.signor.download import DownloadKey, get_signor_df
+from pyobo.struct import CHARLIE_TERM, HUMAN_TERM, PYOBO_INJECTED
+from pyobo.struct.typedef import exact_match, has_component, has_member
+
+__all__ = [
+    "SignorGetter",
+]
+
+PREFIX = "signor"
+
+PROTEIN_FAMILY = (
+    Term(reference=default_reference(PREFIX, "protein-family"))
+    .append_contributor(CHARLIE_TERM)
+    .append_comment(PYOBO_INJECTED)
+)
+PROTEIN_COMPLEX = (
+    Term(reference=default_reference(PREFIX, "protein-complex"))
+    .append_contributor(CHARLIE_TERM)
+    .append_comment(PYOBO_INJECTED)
+)
+PHENOTYPE = (
+    Term(reference=default_reference(PREFIX, "phenotype"))
+    .append_contributor(CHARLIE_TERM)
+    .append_comment(PYOBO_INJECTED)
+)
+STIMULUS = (
+    Term(reference=default_reference(PREFIX, "stimulus"))
+    .append_contributor(CHARLIE_TERM)
+    .append_comment(PYOBO_INJECTED)
+)
+ROOT_TERMS = (PROTEIN_FAMILY, PROTEIN_COMPLEX, PHENOTYPE, STIMULUS)
+
+
+class SignorGetter(Obo):
+    """An ontology representation of SIGNOR complexes."""
+
+    ontology = bioversions_key = PREFIX
+    typedefs = [exact_match, has_component, has_member]
+    root_terms = [r.reference for r in ROOT_TERMS]
+
+    def iter_terms(self, force: bool = False) -> Iterable[Term]:
+        """Iterate over terms in the ontology."""
+        return iter_terms(version=self._version_or_raise, force=force)
+
+
+def iter_terms(version: str, force: bool = False) -> Iterable[Term]:
+    """Iterate over terms."""
+    yield CHARLIE_TERM
+    yield HUMAN_TERM
+    yield from ROOT_TERMS
+
+    complexes_df = get_signor_df(PREFIX, version=version, force=force, key=DownloadKey.complex)
+    for identifier, name, proteins in complexes_df.values:
+        term = Term.from_triple(PREFIX, identifier, name)
+        term.append_parent(PROTEIN_COMPLEX)
+        for part_id in proteins.split(","):
+            part_id = part_id.strip()
+            if part_id.startswith("SIGNOR-"):
+                part = Reference(prefix="signor", identifier=part_id)
+            elif part_id.startswith("CHEBI:"):
+                part = Reference(prefix="chebi", identifier=part_id.removeprefix("CHEBI:"))
+            else:
+                part = Reference(prefix="uniprot", identifier=part_id)
+            term.annotate_object(has_component, part)
+        yield term
+
+    family_df = get_signor_df(PREFIX, version=version, force=force, key=DownloadKey.family)
+    for identifier, name, proteins in family_df.values:
+        term = Term.from_triple(PREFIX, identifier, name)
+        term.append_parent(PROTEIN_FAMILY)
+        for uniprot_id in proteins.split(","):
+            uniprot_id = uniprot_id.strip()
+            term.annotate_object(has_member, Reference(prefix="uniprot", identifier=uniprot_id))
+        yield term
+
+    stimulus_df = get_signor_df(PREFIX, version=version, force=force, key=DownloadKey.stimulus)
+    # for some reason, there are many duplicates in this file
+    stimulus_df = stimulus_df.drop_duplicates()
+    for identifier, name, description in stimulus_df.values:
+        term = Term.from_triple(PREFIX, identifier, name, definition=_clean_descr(description))
+        term.append_parent(STIMULUS)
+        yield term
+
+    phenotypes_df = get_signor_df(PREFIX, version=version, force=force, key=DownloadKey.phenotype)
+    for identifier, name, description in phenotypes_df.values:
+        term = Term.from_triple(PREFIX, identifier, name, definition=_clean_descr(description))
+        term.append_parent(PHENOTYPE)
+        yield term
+
+
+def _clean_descr(d) -> str | None:
+    if pd.isna(d):
+        return None
+    return d.replace("\n", " ")
+
+
+if __name__ == "__main__":
+    SignorGetter.cli()

pyobo/sources/slm.py

@@ -5,9 +5,9 @@ from collections.abc import Iterable
 import pandas as pd
 from tqdm.auto import tqdm
 
-from pyobo import Obo, Reference, Term
+from pyobo import Obo, Reference, Term, TypeDef
 from pyobo.struct.struct import abbreviation as abbreviation_typedef
-from pyobo.struct.typedef import exact_match, has_inchi, has_smiles
+from pyobo.struct.typedef import exact_match, has_citation, has_inchi, has_smiles
 from pyobo.utils.path import ensure_df
 
 __all__ = [
@@ -36,13 +36,14 @@ COLUMNS = [
     "HMDB",
     "PMID",
 ]
+LEVEL = TypeDef.default(PREFIX, "level", is_metadata_tag=True)
 
 
 class SLMGetter(Obo):
     """An ontology representation of SwissLipid's lipid nomenclature."""
 
     ontology = bioversions_key = PREFIX
-    typedefs = [exact_match]
+    typedefs = [exact_match, LEVEL, has_inchi, has_smiles, has_citation]
     synonym_typedefs = [abbreviation_typedef]
 
     def iter_terms(self, force: bool = False) -> Iterable[Term]:
@@ -50,9 +51,7 @@ class SLMGetter(Obo):
         return iter_terms(force=force, version=self._version_or_raise)
 
 
-def get_obo(force: bool = False) -> Obo:
-    """Get SwissLipids as OBO."""
-    return SLMGetter(force=force)
+INVALID_INCHI = {"-", "none"}
 
 
 def iter_terms(version: str, force: bool = False):
@@ -90,27 +89,25 @@ def iter_terms(version: str, force: bool = False):
             raise ValueError(identifier)
         term = Term.from_triple(PREFIX, identifier, name)
         if pd.notna(level):
-            term.append_property("level", level)
+            term.annotate_string(LEVEL, level)
         if pd.notna(abbreviation):
             term.append_synonym(abbreviation, type=abbreviation_typedef)
         if pd.notna(synonyms):
             for synonym in synonyms.split("|"):
                 term.append_synonym(synonym.strip())
         if pd.notna(smiles):
-            term.append_property(has_smiles, smiles)
+            term.annotate_string(has_smiles, smiles)
         if pd.notna(inchi) and inchi != "InChI=none":
             if inchi.startswith("InChI="):
                 inchi = inchi[len("InChI=") :]
-            term.append_property(has_inchi, inchi)
+            term.annotate_string(has_inchi, inchi)
         if pd.notna(inchikey):
             inchikey = inchikey.removeprefix("InChIKey=").strip()
-            if inchikey and inchikey != "none":
+            if inchikey and inchikey not in INVALID_INCHI:
                 try:
                     inchi_ref = Reference(prefix="inchikey", identifier=inchikey)
                 except ValueError:
-                    tqdm.write(
-                        f"[slm:{identifier}] had invalid inchikey reference: ({type(inchikey)}) {inchikey}"
-                    )
+                    tqdm.write(f"[slm:{identifier}] had invalid inchikey reference: `{inchikey}`")
                 else:
                     term.append_exact_match(inchi_ref)
         for chebi_id in _split(chebi_ids):
@@ -120,7 +117,7 @@ def iter_terms(version: str, force: bool = False):
         for hmdb_id in _split(hmdb_ids):
             term.append_exact_match(("hmdb", hmdb_id))
         for pubmed_id in _split(pubmed_ids):
-            term.append_provenance(("pubmed", pubmed_id))
+            term.append_provenance(Reference(prefix="pubmed", identifier=pubmed_id))
         # TODO how to handle class, parents, and components?
         yield term
 
@@ -134,4 +131,4 @@ def _split(s: str) -> Iterable[str]:
 
 
 if __name__ == "__main__":
-    get_obo().write_default(write_obo=True, use_tqdm=True)
+    SLMGetter.cli()

pyobo/sources/umls/__init__.py

@@ -1,3 +1,9 @@
 """Converter for UMLS."""
 
-from .umls import UMLSGetter, get_obo  # noqa: F401
+from .sty import UMLSSTyGetter
+from .umls import UMLSGetter
+
+__all__ = [
+    "UMLSGetter",
+    "UMLSSTyGetter",
+]

pyobo/sources/umls/get_synonym_types.py

@@ -1,19 +1,22 @@
 """Utilities for UMLS synonyms."""
 
+import re
 from collections.abc import Mapping
 from pathlib import Path
 
 import requests
 from bs4 import BeautifulSoup
 
+from pyobo.struct import SynonymTypeDef, default_reference
 from pyobo.utils.io import open_map_tsv, write_map_tsv
 
-__all__ = ["get_umls_synonyms"]
+__all__ = ["get_umls_synonyms", "get_umls_typedefs"]
 
 HERE = Path(__file__).parent.resolve()
 SYNONYM_TYPE_PATH = HERE.joinpath("synonym_types.tsv")
 
 ABBREVIATIONS_URL = "https://www.nlm.nih.gov/research/umls/knowledge_sources/metathesaurus/release/abbreviations.html"
+SPACES = re.compile(r"\s+")
 
 
 def get_umls_synonyms(*, refresh: bool = False) -> Mapping[str, str]:
@@ -23,14 +26,27 @@ def get_umls_synonyms(*, refresh: bool = False) -> Mapping[str, str]:
     res = requests.get(ABBREVIATIONS_URL, timeout=5)
     soup = BeautifulSoup(res.text, features="html.parser")
     table = soup.find(id="mrdoc_TTY")
-    body = table.find("tbody")
+    if table is None:
+        raise ValueError
+    body = table.find("tbody")  # type:ignore[attr-defined]
+    if body is None:
+        raise ValueError
     rv = {}
     for row in body.find_all("tr"):
         left, right = row.find_all("td")
-        rv[left.text.strip()] = right.text.strip()
+        rv[left.text.strip()] = SPACES.sub(" ", right.text.strip())
     write_map_tsv(path=SYNONYM_TYPE_PATH, rv=rv, header=["key", "name"])
     return rv
 
 
+def get_umls_typedefs(*, refresh: bool = False) -> dict[str, SynonymTypeDef]:
+    """Get all synonym type definitions."""
+    umls_synonyms = get_umls_synonyms(refresh=refresh)
+    return {
+        identifier: SynonymTypeDef(reference=default_reference("umls", identifier, name=name))
+        for identifier, name in umls_synonyms.items()
+    }
+
+
 if __name__ == "__main__":
-    get_umls_synonyms(refresh=True)
+    get_umls_typedefs(refresh=True)

pyobo/sources/umls/sty.py

@@ -0,0 +1,57 @@
+"""Converter for UMLS Semantic Types."""
+
+from collections.abc import Iterable
+
+from pyobo import Obo, Reference, Term, default_reference
+from pyobo.struct.typedef import has_category
+from pyobo.utils.path import ensure_df
+
+__all__ = [
+    "UMLSSTyGetter",
+]
+
+PREFIX = "sty"
+
+URL = "https://www.nlm.nih.gov/research/umls/knowledge_sources/semantic_network/SemGroups.txt"
+
+
+class UMLSSTyGetter(Obo):
+    """An ontology representation of UMLS Semantic Types."""
+
+    ontology = PREFIX
+    bioversions_key = "umls"
+    typedefs = [has_category]
+
+    def iter_terms(self, force: bool = False) -> Iterable[Term]:
+        """Iterate over terms in the ontology."""
+        return iter_terms(version=self._version_or_raise)
+
+
+COLUMNS = [
+    "group",
+    "group_label",
+    "sty_id",
+    "sty_name",
+]
+
+
+def iter_terms(version: str) -> Iterable[Term]:
+    """Iterate over UMLS terms."""
+    df = ensure_df(PREFIX, url=URL, version=version, sep="|", header=None, names=COLUMNS)
+
+    extras = {
+        group: Term(
+            reference=default_reference(PREFIX, group, name=group_label),
+        )
+        for group, group_label in df[["group", "group_label"]].drop_duplicates().values
+    }
+    yield from extras.values()
+
+    for group, _group_label, sty_id, sty_name in df.values:
+        term = Term(reference=Reference(prefix="sty", identifier=sty_id, name=sty_name))
+        term.append_parent(extras[group])
+        yield term
+
+
+if __name__ == "__main__":
+    UMLSSTyGetter.cli()

pyobo/sources/umls/synonym_types.tsv

@@ -146,6 +146,7 @@ OAM	Obsolete Modifier Abbreviation
 OAP	Obsolete active preferred term
 OAS	Obsolete active synonym
 OC	Nursing outcomes
+ODN	Obsolete Display Name
 OET	Obsolete entry term
 OF	Obsolete fully specified name
 OL	Non-current Lower Level Term
@@ -188,7 +189,6 @@ PX	Expanded preferred terms (pair with PS)
 PXQ	Preferred qualifier term
 QAB	Qualifier abbreviation
 QEV	Qualifier entry version
-QSV	Qualifier sort version
 RAB	Root abbreviation
 RHT	Root hierarchical term
 RPT	Root preferred term

pyobo/sources/umls/umls.py

@@ -15,7 +15,7 @@ from umls_downloader import open_umls, open_umls_semantic_types
 
 from pyobo import Obo, Reference, Synonym, SynonymTypeDef, Term
 
-from .get_synonym_types import get_umls_synonyms
+from .get_synonym_types import get_umls_typedefs
 
 __all__ = [
     "UMLSGetter",
@@ -46,30 +46,26 @@ RRF_COLUMNS = [
 
 PREFIX = "umls"
 SOURCE_VOCAB_URL = "https://www.nlm.nih.gov/research/umls/sourcereleasedocs/index.html"
-SYNONYM_ABB = get_umls_synonyms()
+UMLS_TYPEDEFS: dict[str, SynonymTypeDef] = get_umls_typedefs()
 
 
 class UMLSGetter(Obo):
     """An ontology representation of UMLS."""
 
     ontology = bioversions_key = PREFIX
-    synonym_typedefs = [SynonymTypeDef.from_text(v) for v in SYNONYM_ABB.values()]
+    synonym_typedefs = list(UMLS_TYPEDEFS.values())
 
     def iter_terms(self, force: bool = False) -> Iterable[Term]:
         """Iterate over terms in the ontology."""
         return iter_terms(version=self._version_or_raise)
 
 
-def get_obo() -> Obo:
-    """Get UMLS as OBO."""
-    return UMLSGetter()
-
-
 def get_semantic_types() -> Mapping[str, set[str]]:
     """Get UMLS semantic types for each term."""
     dd = defaultdict(set)
     with open_umls_semantic_types() as file:
-        for line in tqdm(file, unit_scale=True):
+        # this is very fast and doesn't need a progress bar
+        for line in file:
             cui, sty, _ = line.decode("utf8").split("|", 2)
             dd[cui].add(sty)
     return dict(dd)
@@ -80,7 +76,7 @@ def iter_terms(version: str) -> Iterable[Term]:
     semantic_types = get_semantic_types()
 
     with open_umls(version=version) as file:
-        it = tqdm(file, unit_scale=True, desc="[umls] parsing")
+        it = tqdm(file, unit_scale=True, desc="[umls] parsing", total=16_700_000)
         lines = (line.decode("utf-8").strip().split("|") for line in it)
         for cui, cui_lines in itt.groupby(lines, key=operator.itemgetter(0)):
             df = pd.DataFrame(list(cui_lines), columns=RRF_COLUMNS)
@@ -96,38 +92,38 @@ def iter_terms(version: str) -> Iterable[Term]:
                 continue
 
             df["TTY - Term Type in Source"] = df["TTY - Term Type in Source"].map(
-                SYNONYM_ABB.__getitem__
+                UMLS_TYPEDEFS.__getitem__
             )
 
             _r = pref_rows_df.iloc[0]
             sdf = df[["SAB - source name", "CODE", "TTY - Term Type in Source", "STR"]]
 
             synonyms = []
-            xrefs = []
+            xrefs = set()
             for source, identifier, synonym_type, synonym in sdf.values:
                 norm_source = bioregistry.normalize_prefix(source)
-                if norm_source is None or not identifier:
+                if not norm_source or not identifier or "," in identifier:
                     provenance = []
                 else:
-                    ref = Reference(prefix=norm_source, identifier=identifier)
-                    provenance = [ref]
-                    xrefs.append(ref)
+                    try:
+                        ref = Reference(prefix=norm_source, identifier=identifier)
+                    except ValueError:
+                        continue
+                    else:
+                        provenance = [ref]
+                        xrefs.add(ref)
                 synonyms.append(
                     Synonym(
                         name=synonym,
                         provenance=provenance,
-                        type=SynonymTypeDef.from_text(synonym_type),
+                        type=synonym_type.reference,
                     )
                 )
 
-            xrefs = sorted(
-                set(xrefs), key=lambda reference: (reference.prefix, reference.identifier)
-            )
-
             term = Term(
                 reference=Reference(prefix=PREFIX, identifier=cui, name=_r["STR"]),
                 synonyms=synonyms,
-                xrefs=xrefs,
+                xrefs=sorted(xrefs),
             )
             for sty_id in semantic_types.get(cui, set()):
                 term.append_parent(Reference(prefix="sty", identifier=sty_id))

pyobo/sources/unimod.py

@@ -0,0 +1,46 @@
+"""Unimod provides an OBO file, but it's got lots of errors in its encoding."""
+
+from collections.abc import Iterable
+
+from lxml import etree
+
+from pyobo.struct import Obo, Reference, Term
+from pyobo.utils.path import ensure_path
+
+URL = "https://www.unimod.org/xml/unimod.xml"
+PREFIX_MAP = {"umod": "http://www.unimod.org/xmlns/schema/unimod_2"}
+PREFIX = "unimod"
+
+
+class UnimodGetter(Obo):
+    """An ontology representation of the unimod modifications."""
+
+    ontology = bioversions_key = PREFIX
+    dynamic_version = True
+
+    def iter_terms(self, force: bool = False) -> Iterable[Term]:
+        """Iterate over terms in the ontology."""
+        return get_terms()
+
+
+def get_terms() -> Iterable[Term]:
+    """Get terms."""
+    path = ensure_path("unimod", url=URL)
+    x = etree.parse(path).getroot()
+    mods = x.findall("umod:modifications/umod:mod", namespaces=PREFIX_MAP)
+    return map(_mod_to_term, mods)
+
+
+def _mod_to_term(mod: etree.Element) -> Term:
+    title = mod.attrib["title"]
+    name = mod.attrib["full_name"]
+    identifier = mod.attrib["record_id"]
+    term = Term(
+        reference=Reference(prefix=PREFIX, identifier=identifier, name=title),
+        definition=name if name != title else None,
+    )
+    return term
+
+
+if __name__ == "__main__":
+    UnimodGetter.cli()

pyobo/sources/uniprot/__init__.py

@@ -4,7 +4,7 @@ from .uniprot import PREFIX, UniProtGetter
 from .uniprot_ptm import UniProtPtmGetter
 
 __all__ = [
+    "PREFIX",
     "UniProtGetter",
     "UniProtPtmGetter",
-    "PREFIX",
 ]