def test_subject_fullname():
s = association.Subject(Curie.from_str("HELLO:12345"), "Hello object",
["fullname"], [], ["protein"],
association.Curie.from_str("NCBITaxon:12345"))
assert "fullname" == s.fullname_field()
s = association.Subject(Curie.from_str("HELLO:12345"), "Hello object",
["fullname", "another_name"], [], ["protein"],
association.Curie.from_str("NCBITaxon:12345"))
assert "fullname|another_name" == s.fullname_field()
s = association.Subject(Curie.from_str("HELLO:12345"), "Hello object",
["fullname"], [], ["protein"],
association.Curie.from_str("NCBITaxon:12345"))
assert "fullname" == s.fullname_field(max=1)
def test_rdfgen_includes_taxon_in_gp_class():
assoc = association.GoAssociation(
source_line=
"PomBase\tSPAC25B8.17\typf1\t\tGO:1990578\tGO_REF:0000024\tISO\tSGD:S000001583\tC\tintramembrane aspartyl protease of the perinuclear ER membrane Ypf1 (predicted)\tppp81\tprotein\ttaxon:4896\t20150305\tPomBase\t\t",
subject=association.Subject(
id=association.Curie("PomBase", "SPAC25B8.17"),
label="ypf1",
type="protein",
fullname=
"intramembrane aspartyl protease of the perinuclear ER membrane Ypf1 (predicted)",
synonyms=["ppp81"],
taxon=association.Curie("NCBITaxon", "4896")),
object=association.Term(id=association.Curie("GO", "0000006"),
taxon=association.Curie("NCBITaxon", "4896")),
negated=False,
qualifiers=[],
aspect=association.Aspect("C"),
relation=association.Curie("BFO", "0000050"),
interacting_taxon=association.Curie("NCBITaxon", "555"),
evidence=association.Evidence(
type=association.Curie("ECO", "0000266"),
has_supporting_reference=[association.Curie("GO_REF", "0000024")],
with_support_from=[
association.ConjunctiveSet(
elements=[association.Curie("SGD", "S000001583")])
]),
provided_by=association.Provider("PomBase"),
date=association.Date("20150305"),
subject_extensions=[
association.ExtensionUnit(
relation=association.Curie("rdfs", "subClassOf"),
term=association.Curie("UniProtKB", "P12345"))
],
object_extensions=[
association.ConjunctiveSet(elements=[
association.ExtensionUnit(relation=association.Curie(
"BFO", "0000050"),
term=association.Curie("X", "1")),
association.ExtensionUnit(
relation=association.Curie("BFO", "0000066"),
term=association.Curie("GO", "0016020"))
]),
association.ConjunctiveSet(elements=[
association.ExtensionUnit(
relation=association.Curie("RO", "0002233"),
term=association.Curie("PomBase", "12345"))
])
],
properties=dict())
rdfWriter = TurtleRdfWriter(label="pombase_single.ttl")
gaf_transformer = CamRdfTransform(writer=rdfWriter)
gaf_transformer.translate(assoc)
gaf_transformer.provenance()
gp_res = rdfWriter.graph.query(gene_product_class_query())
for row in gp_res:
assert str(row["cls"]) == "http://identifiers.org/pombase/SPAC25B8.17"
assert str(
row["taxon"]) == "http://purl.obolibrary.org/obo/NCBITaxon_4896"
def to_association(gaf_line: List[str], report=None, group="unknown", dataset="unknown", qualifier_parser=assocparser.Qualifier2_1(), bio_entities=None) -> assocparser.ParseResult:
report = Report(group=group, dataset=dataset) if report is None else report
bio_entities = collections.BioEntities(dict()) if bio_entities is None else bio_entities
source_line = "\t".join(gaf_line)
if source_line == "":
report.error(source_line, "Blank Line", "EMPTY", "Blank lines are not allowed", rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if len(gaf_line) > 17:
# If we see more than 17 columns, we will just cut off the columns after column 17
report.warning(source_line, assocparser.Report.WRONG_NUMBER_OF_COLUMNS, "",
msg="There were more than 17 columns in this line. Proceeding by cutting off extra columns after column 17.",
rule=1)
gaf_line = gaf_line[:17]
if 17 > len(gaf_line) >= 15:
gaf_line += [""] * (17 - len(gaf_line))
if len(gaf_line) != 17:
report.error(source_line, assocparser.Report.WRONG_NUMBER_OF_COLUMNS, "",
msg="There were {columns} columns found in this line, and there should be 15 (for GAF v1) or 17 (for GAF v2)".format(columns=len(gaf_line)), rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
## check for missing columns
## We use indeces here because we run GO RULES before we split the vals into individual variables
DB_INDEX = 0
DB_OBJECT_INDEX = 1
TAXON_INDEX = 12
REFERENCE_INDEX = 5
if gaf_line[DB_INDEX] == "":
report.error(source_line, Report.INVALID_IDSPACE, "EMPTY", "col1 is empty", taxon=gaf_line[TAXON_INDEX], rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gaf_line[DB_OBJECT_INDEX] == "":
report.error(source_line, Report.INVALID_ID, "EMPTY", "col2 is empty", taxon=gaf_line[TAXON_INDEX], rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gaf_line[REFERENCE_INDEX] == "":
report.error(source_line, Report.INVALID_ID, "EMPTY", "reference column 6 is empty", taxon=gaf_line[TAXON_INDEX], rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
parsed_taxons_result = gaf_line_validators["taxon"].validate(gaf_line[TAXON_INDEX]) # type: assocparser.ValidateResult
if not parsed_taxons_result.valid:
report.error(source_line, Report.INVALID_TAXON, parsed_taxons_result.original, parsed_taxons_result.message, taxon=parsed_taxons_result.original, rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
taxon = parsed_taxons_result.parsed[0]
date = assocparser.parse_date(gaf_line[13], report, source_line)
if date is None:
return assocparser.ParseResult(source_line, [], True, report=report)
interacting_taxon = parsed_taxons_result.parsed[1] if len(parsed_taxons_result.parsed) == 2 else None
subject_curie = association.Curie(gaf_line[0], gaf_line[1])
subject = association.Subject(subject_curie, gaf_line[2], [gaf_line[9]], gaf_line[10].split("|"), [association.map_gp_type_label_to_curie(gaf_line[11])], taxon)
gpi_entity = bio_entities.get(subject_curie)
if gpi_entity is not None and subject != gpi_entity:
subject = gpi_entity
# column 4 is qualifiers -> index 3
# For allowed, see http://geneontology.org/docs/go-annotations/#annotation-qualifiers
# We use the below validate to check validaty if qualifiers, not as much to *parse* them into the GoAssociation object.
# For GoAssociation we will use the above qualifiers list. This is fine because the above does not include `NOT`, etc
# This is confusing, and we can fix later on by consolidating qualifier and relation in GoAssociation.
parsed_qualifiers = qualifier_parser.validate(gaf_line[3])
if not parsed_qualifiers.valid:
report.error(source_line, Report.INVALID_QUALIFIER, parsed_qualifiers.original, parsed_qualifiers.message, taxon=gaf_line[TAXON_INDEX], rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
aspect = gaf_line[8]
negated, relation_label, qualifiers = assocparser._parse_qualifier(gaf_line[3], aspect)
# Note: Relation label is grabbed from qualifiers, if any exist in _parse_qualifier
qualifiers = [association.Curie.from_str(curie_util.contract_uri(relations.lookup_label(q), strict=False)[0]) for q in qualifiers]
object = association.Term(association.Curie.from_str(gaf_line[4]), taxon)
if isinstance(object, association.Error):
report.error(source_line, Report.INVALID_SYMBOL, gaf_line[4], "Problem parsing GO Term", taxon=gaf_line[TAXON_INDEX], rule=1)
# References
references = [association.Curie.from_str(e) for e in gaf_line[5].split("|") if e]
for r in references:
if isinstance(r, association.Error):
report.error(source_line, Report.INVALID_SYMBOL, gaf_line[5], "Problem parsing references", taxon=gaf_line[TAXON_INDEX], rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
gorefs = [ref for ref in references if ref.namespace == "GO_REF"] + [None]
eco_curie = ecomap.coderef_to_ecoclass(gaf_line[6], reference=gorefs[0])
if eco_curie is None:
report.error(source_line, Report.UNKNOWN_EVIDENCE_CLASS, gaf_line[6], msg="Expecting a known ECO GAF code, e.g ISS", rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
withfroms = association.ConjunctiveSet.str_to_conjunctions(gaf_line[7])
if isinstance(withfroms, association.Error):
report.error(source_line, Report.INVALID_SYMBOL, gaf_line[7], "Problem parsing with/from", taxon=gaf_line[TAXON_INDEX], rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
evidence_type = association.Curie.from_str(eco_curie)
if isinstance(evidence_type, association.Error):
report.error(source_line, Report.INVALID_SYMBOL, gaf_line[6], "Problem parsing evidence type", taxon=gaf_line[TAXON_INDEX], rule=1)
evidence = association.Evidence(association.Curie.from_str(eco_curie), references, withfroms)
if any([isinstance(e, association.Error) for e in evidence.has_supporting_reference]):
first_error = [e for e in evidence.has_supporting_reference if isinstance(e, association.Error)][0]
report.error(source_line, Report.INVALID_SYMBOL, gaf_line[5], first_error.info, taxon=str(taxon), rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
subject_extensions = []
if gaf_line[16]:
subject_filler = association.Curie.from_str(gaf_line[16])
if isinstance(subject_filler, association.Error):
report.error(source_line, assocparser.Report.INVALID_ID, gaf_line[16], subject_filler.info, taxon=str(taxon), rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
# filler is not an Error, so keep moving
subject_extensions.append(association.ExtensionUnit(association.Curie.from_str("rdfs:subClassOf"), subject_filler))
conjunctions = []
if gaf_line[15]:
conjunctions = association.ConjunctiveSet.str_to_conjunctions(
gaf_line[15],
conjunct_element_builder=lambda el: association.ExtensionUnit.from_str(el))
if isinstance(conjunctions, association.Error):
report.error(source_line, Report.EXTENSION_SYNTAX_ERROR, conjunctions.info, "extensions should be relation(curie) and relation should have corresponding URI", taxon=str(taxon), rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
relation_uri = relations.lookup_label(relation_label)
if relation_uri is None:
report.error(source_line, assocparser.Report.INVALID_QUALIFIER, relation_label, "Could not find CURIE for relation `{}`".format(relation_label), taxon=str(taxon), rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
# We don't have to check that this is well formed because we're grabbing it from the known relations URI map.
relation_curie = association.Curie.from_str(curie_util.contract_uri(relation_uri)[0])
a = association.GoAssociation(
source_line="\t".join(gaf_line),
subject=subject,
relation=relation_curie,
object=object,
negated=negated,
qualifiers=qualifiers,
aspect=aspect,
interacting_taxon=interacting_taxon,
evidence=evidence,
subject_extensions=subject_extensions,
object_extensions=conjunctions,
provided_by=gaf_line[14],
date=date,
properties={})
return assocparser.ParseResult(source_line, [a], False, report=report)
def from_2_0(gpad_line: List[str],
report=None,
group="unknown",
dataset="unknown",
bio_entities=None):
source_line = "\t".join(gpad_line)
if source_line == "":
report.error(source_line,
"Blank Line",
"EMPTY",
"Blank lines are not allowed",
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if len(gpad_line) > 12:
report.warning(
source_line,
assocparser.Report.WRONG_NUMBER_OF_COLUMNS,
"",
msg=
"There were more than 12 columns in this line. Proceeding by cutting off extra columns.",
rule=1)
gpad_line = gpad_line[:12]
if 12 > len(gpad_line) >= 10:
gpad_line += [""] * (12 - len(gpad_line))
if len(gpad_line) != 12:
report.error(
source_line,
assocparser.Report.WRONG_NUMBER_OF_COLUMNS,
"",
msg=
"There were {columns} columns found in this line, and there should be between 10 and 12"
.format(columns=len(gpad_line)),
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
## check for missing columns
## We use indeces here because we run GO RULES before we split the vals into individual variables
SUBJECT_CURIE = 0
RELATION = 2
ONTOLOGY_CLASS_INDEX = 3
REFERENCE_INDEX = 4
EVIDENCE_INDEX = 5
DATE_INDEX = 8
ASSIGNED_BY_INDEX = 9
required = [
SUBJECT_CURIE, RELATION, ONTOLOGY_CLASS_INDEX, REFERENCE_INDEX,
EVIDENCE_INDEX, DATE_INDEX, ASSIGNED_BY_INDEX
]
for req in required:
if gpad_line[req] == "":
report.error(source_line,
Report.INVALID_ID,
"EMPTY",
"Column {} is empty".format(req + 1),
rule=1)
return assocparser.ParseResult(source_line, [],
True,
report=report)
taxon = association.Curie("NCBITaxon", "0")
subject_curie = association.Curie.from_str(gpad_line[SUBJECT_CURIE])
if subject_curie.is_error():
report.error(source_line,
Report.INVALID_SYMBOL,
gpad_line[SUBJECT_CURIE],
"Problem parsing DB Object",
taxon=str(taxon),
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
subject = association.Subject(subject_curie, "", "", [], "", taxon)
entity = bio_entities.get(subject_curie)
if entity is not None:
# If we found a subject entity, then set `subject` to the found entity
subject = entity
taxon = subject.taxon
negated = gpad_line[1] == "NOT"
relation = association.Curie.from_str(gpad_line[RELATION])
if relation.is_error():
report.error(source_line,
Report.INVALID_SYMBOL,
gpad_line[RELATION],
"Problem parsing Relation",
taxon=str(taxon),
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
go_term = association.Curie.from_str(gpad_line[ONTOLOGY_CLASS_INDEX])
if go_term.is_error():
report.error(source_line,
Report.INVALID_SYMBOL,
gpad_line[ONTOLOGY_CLASS_INDEX],
"Problem parsing GO Term",
taxon=str(taxon),
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
object = association.Term(go_term, taxon)
evidence_type = association.Curie.from_str(gpad_line[EVIDENCE_INDEX])
if evidence_type.is_error():
report.error(source_line,
Report.INVALID_SYMBOL,
gpad_line[EVIDENCE_INDEX],
"Problem parsing Evidence ECO Curie",
taxon=str(taxon),
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
references = [
association.Curie.from_str(e)
for e in gpad_line[REFERENCE_INDEX].split("|") if e
]
for r in references:
if r.is_error():
report.error(source_line,
Report.INVALID_SYMBOL,
gpad_line[REFERENCE_INDEX],
"Problem parsing references",
taxon=str(taxon),
rule=1)
return assocparser.ParseResult(source_line, [],
True,
report=report)
withfroms = association.ConjunctiveSet.str_to_conjunctions(
gpad_line[6]) # Returns a list of ConjuctiveSets or Error
if isinstance(withfroms, association.Error):
report.error(source_line,
Report.INVALID_SYMBOL,
gpad_line[6],
"Problem parsing With/From column",
taxon=str(taxon),
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
evidence = association.Evidence(evidence_type, references, withfroms)
interacting_taxon = None
if gpad_line[7] != "":
interacting_taxon = association.Curie.from_str(gpad_line[7])
if interacting_taxon.is_error():
report.error(source_line,
Report.INVALID_SYMBOL,
gpad_line[7],
"Problem parsing Interacting Taxon",
taxon=str(taxon),
rule=1)
return assocparser.ParseResult(source_line, [],
True,
report=report)
date = assocparser.parse_iso_date(gpad_line[DATE_INDEX], report,
source_line)
if date is None:
return assocparser.ParseResult(source_line, [], True, report=report)
conjunctions = []
# The elements of the extension units are Curie(Curie)
if gpad_line[10]:
conjunctions = association.ConjunctiveSet.str_to_conjunctions(
gpad_line[10],
conjunct_element_builder=lambda el: association.ExtensionUnit.
from_curie_str(el))
if isinstance(conjunctions, association.Error):
report.error(source_line,
Report.EXTENSION_SYNTAX_ERROR,
conjunctions.info,
"extensions should be relation(curie)",
taxon=str(taxon),
rule=1)
return assocparser.ParseResult(source_line, [],
True,
report=report)
properties_list = association.parse_annotation_properties(gpad_line[11])
a = association.GoAssociation(source_line=source_line,
subject=subject,
relation=relation,
object=object,
negated=negated,
qualifiers=[relation],
aspect=None,
interacting_taxon=interacting_taxon,
evidence=evidence,
subject_extensions=[],
object_extensions=conjunctions,
provided_by=gpad_line[9],
date=date,
properties=properties_list)
return assocparser.ParseResult(source_line, [a], False, report=report)
def from_1_2(gpad_line: List[str],
report=None,
group="unknown",
dataset="unknown",
bio_entities=None):
source_line = "\t".join(gpad_line)
if source_line == "":
report.error(source_line,
"Blank Line",
"EMPTY",
"Blank lines are not allowed",
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if len(gpad_line) > 12:
report.warning(
source_line,
assocparser.Report.WRONG_NUMBER_OF_COLUMNS,
"",
msg=
"There were more than 12 columns in this line. Proceeding by cutting off extra columns.",
rule=1)
gpad_line = gpad_line[:12]
if 12 > len(gpad_line) >= 10:
gpad_line += [""] * (12 - len(gpad_line))
if len(gpad_line) != 12:
report.error(
source_line,
assocparser.Report.WRONG_NUMBER_OF_COLUMNS,
"",
msg=
"There were {columns} columns found in this line, and there should be between 10 and 12"
.format(columns=len(gpad_line)),
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
## check for missing columns
## We use indeces here because we run GO RULES before we split the vals into individual variables
DB_INDEX = 0
DB_OBJECT_INDEX = 1
QUALIFIER = 2
REFERENCE_INDEX = 4
EVIDENCE_INDEX = 5
if gpad_line[DB_INDEX] == "":
report.error(source_line,
Report.INVALID_IDSPACE,
"EMPTY",
"col1 is empty",
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gpad_line[DB_OBJECT_INDEX] == "":
report.error(source_line,
Report.INVALID_ID,
"EMPTY",
"col2 is empty",
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gpad_line[QUALIFIER] == "":
report.error(source_line,
Report.INVALID_TAXON,
"EMPTY",
"qualifier column is empty",
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gpad_line[REFERENCE_INDEX] == "":
report.error(source_line,
Report.INVALID_ID,
"EMPTY",
"reference column is empty",
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gpad_line[EVIDENCE_INDEX] == "":
report.error(source_line,
Report.INVALID_ID,
"EMPTY",
"Evidence column is empty",
rule=1)
taxon = association.Curie("NCBITaxon", "0")
subject_curie = association.Curie(gpad_line[0], gpad_line[1])
subject = association.Subject(subject_curie, "", [""], [], [], taxon)
entity = bio_entities.get(subject_curie)
if entity is not None:
subject = entity
taxon = subject.taxon
go_term = association.Curie.from_str(gpad_line[3])
if go_term.is_error():
report.error(source_line,
Report.INVALID_SYMBOL,
gpad_line[3],
"Problem parsing GO Term",
taxon=str(taxon),
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
object = association.Term(go_term, taxon)
evidence_type = association.Curie.from_str(gpad_line[5])
if evidence_type.is_error():
report.error(source_line,
Report.INVALID_SYMBOL,
gpad_line[5],
"Problem parsing Evidence ECO Curie",
taxon=str(taxon),
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
references = [
association.Curie.from_str(e) for e in gpad_line[4].split("|") if e
]
for r in references:
if r.is_error():
report.error(source_line,
Report.INVALID_SYMBOL,
gpad_line[4],
"Problem parsing references",
taxon=str(taxon),
rule=1)
return assocparser.ParseResult(source_line, [],
True,
report=report)
withfroms = association.ConjunctiveSet.str_to_conjunctions(
gpad_line[6]) # Returns a list of ConjuctiveSets or Error
if isinstance(withfroms, association.Error):
report.error(source_line,
Report.INVALID_SYMBOL,
gpad_line[6],
"Problem parsing With/From column",
taxon=str(taxon),
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
evidence = association.Evidence(evidence_type, references, withfroms)
# Guarenteed to have at least one element, from above check
raw_qs = gpad_line[QUALIFIER].split("|")
negated = "NOT" in raw_qs
looked_up_qualifiers = [
relations.lookup_label(q) for q in raw_qs if q != "NOT"
]
if None in looked_up_qualifiers:
report.error(source_line,
Report.INVALID_QUALIFIER,
raw_qs,
"Could not find a URI for qualifier",
taxon=str(taxon),
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
qualifiers = [
association.Curie.from_str(curie_util.contract_uri(q)[0])
for q in looked_up_qualifiers
]
date = assocparser.parse_date(gpad_line[8], report, source_line)
if date is None:
return assocparser.ParseResult(source_line, [], True, report=report)
interacting_taxon = None
if gpad_line[7]:
taxon_result = gpad_line_validators["taxon"].validate(gpad_line[7])
if not taxon_result.valid:
report.error(source_line,
Report.INVALID_TAXON,
taxon_result.original,
taxon_result.message,
taxon=str(taxon_result.original),
rule=1)
return assocparser.ParseResult(source_line, [],
True,
report=report)
else:
interacting_taxon = taxon_result.parsed[0]
conjunctions = []
if gpad_line[10]:
conjunctions = association.ConjunctiveSet.str_to_conjunctions(
gpad_line[10],
conjunct_element_builder=lambda el: association.ExtensionUnit.
from_str(el))
if isinstance(conjunctions, association.Error):
report.error(source_line,
Report.EXTENSION_SYNTAX_ERROR,
conjunctions.info,
"extensions should be relation(curie)",
taxon=str(taxon),
rule=1)
return assocparser.ParseResult(source_line, [],
True,
report=report)
properties_list = association.parse_annotation_properties(gpad_line[11])
# print(properties_list)
a = association.GoAssociation(source_line=source_line,
subject=subject,
relation=qualifiers[0],
object=object,
negated=negated,
qualifiers=qualifiers,
aspect=None,
interacting_taxon=interacting_taxon,
evidence=evidence,
subject_extensions=[],
object_extensions=conjunctions,
provided_by=gpad_line[9],
date=date,
properties=properties_list)
return assocparser.ParseResult(source_line, [a], False, report=report)
def to_association(gaf_line: List[str],
report=None,
group="unknown",
dataset="unknown") -> assocparser.ParseResult:
report = Report(group=group, dataset=dataset) if report is None else report
source_line = "\t".join(gaf_line)
if source_line == "":
report.error(source_line,
"Blank Line",
"EMPTY",
"Blank lines are not allowed",
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if len(gaf_line) > 17:
# If we see more than 17 columns, we will just cut off the columns after column 17
report.warning(
source_line,
assocparser.Report.WRONG_NUMBER_OF_COLUMNS,
"",
msg=
"There were more than 17 columns in this line. Proceeding by cutting off extra columns after column 17.",
rule=1)
gaf_line = gaf_line[:17]
if 17 > len(gaf_line) >= 15:
gaf_line += [""] * (17 - len(gaf_line))
if len(gaf_line) != 17:
report.error(
source_line,
assocparser.Report.WRONG_NUMBER_OF_COLUMNS,
"",
msg=
"There were {columns} columns found in this line, and there should be 15 (for GAF v1) or 17 (for GAF v2)"
.format(columns=len(gaf_line)),
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
## check for missing columns
## We use indeces here because we run GO RULES before we split the vals into individual variables
DB_INDEX = 0
DB_OBJECT_INDEX = 1
TAXON_INDEX = 12
REFERENCE_INDEX = 5
if gaf_line[DB_INDEX] == "":
report.error(source_line,
Report.INVALID_IDSPACE,
"EMPTY",
"col1 is empty",
taxon=gaf_line[TAXON_INDEX],
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gaf_line[DB_OBJECT_INDEX] == "":
report.error(source_line,
Report.INVALID_ID,
"EMPTY",
"col2 is empty",
taxon=gaf_line[TAXON_INDEX],
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gaf_line[TAXON_INDEX] == "":
report.error(source_line,
Report.INVALID_TAXON,
"EMPTY",
"taxon column is empty",
taxon=gaf_line[TAXON_INDEX],
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gaf_line[REFERENCE_INDEX] == "":
report.error(source_line,
Report.INVALID_ID,
"EMPTY",
"reference column 6 is empty",
taxon=gaf_line[TAXON_INDEX],
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
taxon = gaf_line[12].split("|")
taxon_curie = taxon[0].replace("taxon", "NCBITaxon")
interacting_taxon = taxon[1].replace(
"taxon", "NCBITaxon") if len(taxon) == 2 else None
subject_curie = "{db}:{id}".format(db=gaf_line[0], id=gaf_line[1])
subject = association.Subject(subject_curie, gaf_line[2], gaf_line[9],
gaf_line[10].split("|"), gaf_line[11],
taxon_curie)
aspect = gaf_line[8]
negated, relation, qualifiers = assocparser._parse_qualifier(
gaf_line[3], aspect)
# For allowed, see http://geneontology.org/docs/go-annotations/#annotation-qualifiers
for q in qualifiers:
if q not in allowed_qualifiers:
report.error(
source_line,
Report.INVALID_QUALIFIER,
q,
"Qualifiers must be `contributes_to`, `colocalizes_with`, or `NOT`",
taxon=gaf_line[TAXON_INDEX],
rule=1)
return assocparser.ParseResult(source_line, [],
True,
report=report)
object = association.Term(gaf_line[4], taxon_curie)
evidence = association.Evidence(ecomap.coderef_to_ecoclass(gaf_line[6]),
[e for e in gaf_line[5].split("|") if e],
[e for e in gaf_line[7].split("|") if e])
subject_extensions = [
association.ExtensionUnit("rdfs:subClassOf", gaf_line[16])
] if gaf_line[16] else []
conjunctions = []
if gaf_line[15]:
for conjuncts in gaf_line[15].split("|"):
extension_units = []
for u in conjuncts.split(","):
parsed = relation_tuple.findall(u)
if len(parsed) == 1:
rel, term = parsed[0]
extension_units.append(association.ExtensionUnit(
rel, term))
else:
# Otherwise, something went bad with the regex, and it's a bad parse
report.error(source_line,
Report.EXTENSION_SYNTAX_ERROR,
u,
"extensions should be relation(curie)",
taxon=taxon,
rule=1)
return assocparser.ParseResult(source_line, [],
True,
report=report)
conjunction = association.ExtensionConjunctions(extension_units)
conjunctions.append(conjunction)
object_extensions = association.ExtensionExpression(conjunctions)
looked_up_rel = relations.lookup_label(relation)
if looked_up_rel is None:
report.error(
source_line,
assocparser.Report.INVALID_QUALIFIER,
relation,
"Qualifer must be \"colocalizes_with\", \"contributes_to\", or \"NOT\"",
taxon=taxon,
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
a = association.GoAssociation(
source_line="\t".join(gaf_line),
subject=subject,
relation=curie_util.contract_uri(looked_up_rel)[0],
object=object,
negated=negated,
qualifiers=qualifiers,
aspect=aspect,
interacting_taxon=interacting_taxon,
evidence=evidence,
subject_extensions=subject_extensions,
object_extensions=object_extensions,
provided_by=gaf_line[14],
date=gaf_line[13],
properties={})
return assocparser.ParseResult(source_line, [a], False, report=report)
def line_as_entity_subject(self, line: str):
"""
This uses `parse_line` to produce the old-style dictionary for an Entity and
then converts it to an `association.Subject` instance. This is essentially a
shim for the newer `ontobio.model.collections` and `ontobio.model.association`
modules to produce a `BioEntities` object from a GPI Parser.
"""
# Parse the line first thing. This lets us parse header info and set the GPI
# version state before we move on to the regular conversions.
# If it's a header (starts with `!`) we'll just skip by returning None.
_, entity_dicts = self.parse_line(line)
if line.startswith("!"):
return None
subjects = []
for entity in entity_dicts:
entity_types = []
if self.gpi_version() == "2.0":
entity_types = [
association.Curie.from_str(t) for t in entity["type"]
]
if any(c.is_error() for c in entity_types):
logger.error(
"Skipping `{}` due to malformed CURIE in entity type: `{}`"
.format(line, entity["type"]))
return None
else:
entity_types = entity["type"]
parents = [
association.Curie.from_str(p) for p in entity["parents"]
]
if any(p.is_error() for p in parents):
logger.error(
"Skipping `{}` due to malformed CURIE in parents: `{}`".
format(line, entity["parents"]))
return None
db_xrefs = [association.Curie.from_str(x) for x in entity["xrefs"]]
if any(x.is_error() for x in db_xrefs):
logger.error(
"Skipping `{}` due to malformed CURIE in db-xrefs: `{}`".
format(line, entity["xrefs"]))
return None
complexes = [
association.Curie.from_str(c)
for c in entity["contained_complex_members"]
]
if any(c.is_error() for c in complexes):
logger.error(
"Skipping `{}` due to malformed CURIE in contained complexes: `{}`"
.format(line, entity["contained_complex_members"]))
return None
s = association.Subject(
id=association.Curie.from_str(entity["id"]),
label=entity["label"],
fullname=entity["full_name"],
synonyms=entity["synonyms"],
type=entity_types,
taxon=association.Curie.from_str(entity["taxon"]["id"]),
parents=parents,
contained_complex_members=complexes,
db_xrefs=db_xrefs,
properties=entity["properties"])
subjects.append(s)
return subjects
def to_association(gpad_line: List[str],
report=None,
group="unknown",
dataset="unknown") -> assocparser.ParseResult:
report = Report(group=group, dataset=dataset) if report is None else report
source_line = "\t".join(gpad_line)
if len(gpad_line) > 12:
report.warning(
source_line,
assocparser.Report.WRONG_NUMBER_OF_COLUMNS,
"",
msg=
"There were more than 12 columns in this line. Proceeding by cutting off extra columns.",
rule=1)
gpad_line = gpad_line[:12]
if 12 > len(gpad_line) >= 10:
gpad_line += [""] * (12 - len(gpad_line))
if len(gpad_line) != 12:
report.error(
source_line,
assocparser.Report.WRONG_NUMBER_OF_COLUMNS,
"",
msg=
"There were {columns} columns found in this line, and there should be between 10 and 12"
.format(columns=len(gpad_line)))
return assocparser.ParseResult(source_line, [], True, report=report)
## check for missing columns
## We use indeces here because we run GO RULES before we split the vals into individual variables
DB_INDEX = 0
DB_OBJECT_INDEX = 1
QUALIFIER = 2
REFERENCE_INDEX = 4
EVIDENCE_INDEX = 5
if gpad_line[DB_INDEX] == "":
report.error(source_line,
Report.INVALID_IDSPACE,
"EMPTY",
"col1 is empty",
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gpad_line[DB_OBJECT_INDEX] == "":
report.error(source_line,
Report.INVALID_ID,
"EMPTY",
"col2 is empty",
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gpad_line[QUALIFIER] == "":
report.error(source_line,
Report.INVALID_TAXON,
"EMPTY",
"qualifier column is empty",
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gpad_line[REFERENCE_INDEX] == "":
report.error(source_line,
Report.INVALID_ID,
"EMPTY",
"reference column is empty",
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gpad_line[EVIDENCE_INDEX] == "":
report.error(source_line,
Report.INVALID_ID,
"EMPTY",
"Evidence column is empty",
rule=1)
taxon = ""
subject_curie = "{db}:{id}".format(db=gpad_line[0], id=gpad_line[1])
subject = association.Subject(subject_curie, "", "", [], "", "")
object = association.Term(gpad_line[3], "")
evidence = association.Evidence(gpad_line[5],
[e for e in gpad_line[4].split("|") if e],
[e for e in gpad_line[6].split("|") if e])
raw_qs = gpad_line[2].split("|")
negated = "NOT" in raw_qs
looked_up_qualifiers = [
relations.lookup_label(q) for q in raw_qs if q != "NOT"
]
if None in looked_up_qualifiers:
report.error(source_line,
Report.INVALID_QUALIFIER,
raw_qs,
"Could not find a URI for qualifier",
taxon=taxon,
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
qualifiers = [curie_util.contract_uri(q)[0] for q in looked_up_qualifiers]
conjunctions = []
if gpad_line[11]:
for conjuncts in gpad_line[11].split("|"):
extension_units = []
for u in conjuncts.split(","):
parsed = relation_tuple.findall(u)
if len(parsed) == 1:
rel, term = parsed[0]
extension_units.append(association.ExtensionUnit(
rel, term))
else:
# Otherwise, something went bad with the regex, and it's a bad parse
report.error(source_line,
Report.EXTENSION_SYNTAX_ERROR,
u,
"extensions should be relation(curie)",
taxon=taxon,
rule=1)
return assocparser.ParseResult(source_line, [],
True,
report=report)
conjunction = association.ExtensionConjunctions(extension_units)
conjunctions.append(conjunction)
object_extensions = association.ExtensionExpression(conjunctions)
properties_list = [
prop.split("=") for prop in gpad_line[11].split("|") if prop
]
# print(properties_list)
a = association.GoAssociation(
source_line="\t".join(gpad_line),
subject=subject,
relation="",
object=object,
negated=negated,
qualifiers=qualifiers,
aspect=None,
interacting_taxon=gpad_line[7],
evidence=evidence,
subject_extensions=[],
object_extensions=object_extensions,
provided_by=gpad_line[9],
date=gpad_line[8],
properties={prop[0]: prop[1]
for prop in properties_list if prop})
return assocparser.ParseResult(source_line, [a], False, report=report)
def to_association(
gaf_line: List[str],
report=None,
group="unknown",
dataset="unknown",
qualifier_parser=Qualifier2_1()) -> assocparser.ParseResult:
report = Report(group=group, dataset=dataset) if report is None else report
source_line = "\t".join(gaf_line)
if source_line == "":
report.error(source_line,
"Blank Line",
"EMPTY",
"Blank lines are not allowed",
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if len(gaf_line) > 17:
# If we see more than 17 columns, we will just cut off the columns after column 17
report.warning(
source_line,
assocparser.Report.WRONG_NUMBER_OF_COLUMNS,
"",
msg=
"There were more than 17 columns in this line. Proceeding by cutting off extra columns after column 17.",
rule=1)
gaf_line = gaf_line[:17]
if 17 > len(gaf_line) >= 15:
gaf_line += [""] * (17 - len(gaf_line))
if len(gaf_line) != 17:
report.error(
source_line,
assocparser.Report.WRONG_NUMBER_OF_COLUMNS,
"",
msg=
"There were {columns} columns found in this line, and there should be 15 (for GAF v1) or 17 (for GAF v2)"
.format(columns=len(gaf_line)),
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
## check for missing columns
## We use indeces here because we run GO RULES before we split the vals into individual variables
DB_INDEX = 0
DB_OBJECT_INDEX = 1
TAXON_INDEX = 12
REFERENCE_INDEX = 5
if gaf_line[DB_INDEX] == "":
report.error(source_line,
Report.INVALID_IDSPACE,
"EMPTY",
"col1 is empty",
taxon=gaf_line[TAXON_INDEX],
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gaf_line[DB_OBJECT_INDEX] == "":
report.error(source_line,
Report.INVALID_ID,
"EMPTY",
"col2 is empty",
taxon=gaf_line[TAXON_INDEX],
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gaf_line[TAXON_INDEX] == "":
report.error(source_line,
Report.INVALID_TAXON,
"EMPTY",
"taxon column is empty",
taxon=gaf_line[TAXON_INDEX],
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
if gaf_line[REFERENCE_INDEX] == "":
report.error(source_line,
Report.INVALID_ID,
"EMPTY",
"reference column 6 is empty",
taxon=gaf_line[TAXON_INDEX],
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
taxon = gaf_line[12].split("|")
taxon_curie = taxon[0].replace("taxon", "NCBITaxon")
date = assocparser._normalize_gaf_date(gaf_line[13], report, taxon_curie,
source_line)
if date is None:
return assocparser.ParseResult(source_line, [], True, report=report)
interacting_taxon = taxon[1].replace(
"taxon", "NCBITaxon") if len(taxon) == 2 else None
subject_curie = "{db}:{id}".format(db=gaf_line[0], id=gaf_line[1])
subject = association.Subject(subject_curie, gaf_line[2], gaf_line[9],
gaf_line[10].split("|"), gaf_line[11],
taxon_curie)
aspect = gaf_line[8]
negated, relation, qualifiers = assocparser._parse_qualifier(
gaf_line[3], aspect)
# column 4 is qualifiers -> index 3
# For allowed, see http://geneontology.org/docs/go-annotations/#annotation-qualifiers
parsed_qualifiers = qualifier_parser.validate(gaf_line[3])
if not parsed_qualifiers.valid:
report.error(source_line,
Report.INVALID_QUALIFIER,
parsed_qualifiers.original,
parsed_qualifiers.message,
taxon=gaf_line[TAXON_INDEX],
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
object = association.Term(gaf_line[4], taxon_curie)
evidence = association.Evidence(
ecomap.coderef_to_ecoclass(gaf_line[6]),
[e for e in gaf_line[5].split("|") if e],
association.ConjunctiveSet.str_to_conjunctions(gaf_line[7]))
subject_extensions = [
association.ExtensionUnit("rdfs:subClassOf", gaf_line[16])
] if gaf_line[16] else []
conjunctions = []
if gaf_line[15]:
conjunctions = association.ConjunctiveSet.str_to_conjunctions(
gaf_line[15],
conjunct_element_builder=lambda el: association.ExtensionUnit.
from_str(el))
if isinstance(conjunctions, association.Error):
report.error(source_line,
Report.EXTENSION_SYNTAX_ERROR,
conjunctions.info,
"extensions should be relation(curie)",
taxon=taxon,
rule=1)
return assocparser.ParseResult(source_line, [],
True,
report=report)
looked_up_rel = relations.lookup_label(relation)
if looked_up_rel is None:
report.error(source_line,
assocparser.Report.INVALID_QUALIFIER,
relation,
"Could not find CURIE for relation `{}`".format(relation),
taxon=taxon,
rule=1)
return assocparser.ParseResult(source_line, [], True, report=report)
a = association.GoAssociation(
source_line="\t".join(gaf_line),
subject=subject,
relation=curie_util.contract_uri(looked_up_rel)[0],
object=object,
negated=negated,
qualifiers=qualifiers,
aspect=aspect,
interacting_taxon=interacting_taxon,
evidence=evidence,
subject_extensions=subject_extensions,
object_extensions=conjunctions,
provided_by=gaf_line[14],
date=date,
properties={})
return assocparser.ParseResult(source_line, [a], False, report=report)
def test_subject_types_label():
s = association.Subject(Curie.from_str("HELLO:12345"), "Hello object",
["fullname"], [], ["mRNA", "tRNA"],
association.Curie.from_str("NCBITaxon:12345"))
assert [Curie.from_str("SO:0000234"),
Curie.from_str("SO:0000253")] == s.type
def test_subject_types_unknown():
s = association.Subject(Curie.from_str("HELLO:12345"), "Hello object",
["fullname"], [], [],
association.Curie.from_str("NCBITaxon:12345"))
assert [Curie(namespace="CHEBI", identity="33695")] == s.type
