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 test_build_annotation_inferences(): with open("tests/resources/test.inferences.json") as inferences_file: gaferences = json.load(inferences_file) inferences = gaference.build_annotation_inferences(gaferences) akey = gaference.AnnotationKey( gaference.RelationTo("http://purl.obolibrary.org/obo/BFO_0000050", "http://purl.obolibrary.org/obo/GO_0036064"), "http://purl.obolibrary.org/obo/NCBITaxon_10090", association.ExtensionConjunctions( frozenset([ association.ExtensionUnit( "http://purl.obolibrary.org/obo/BFO_0000050", "http://purl.obolibrary.org/obo/EMAPA_17168"), association.ExtensionUnit( "http://purl.obolibrary.org/obo/BFO_0000050", "http://purl.obolibrary.org/obo/CL_0010009") ]))) val = inferences[akey] expected = gaference.InferenceValue(True, False, [ gaference.RelationTo("http://purl.obolibrary.org/obo/BFO_0000050", "http://purl.obolibrary.org/obo/GO_0097458") ]) assert val == expected
def test_conjunctive_set_str_to_conjunctions(): c = association.ConjunctiveSet.str_to_conjunctions("") assert c == [] c = association.ConjunctiveSet.str_to_conjunctions("MGI:12345") assert c == [association.ConjunctiveSet([Curie.from_str("MGI:12345")])] c = association.ConjunctiveSet.str_to_conjunctions("MGI:12345,MGI:12345") assert c == [ association.ConjunctiveSet( [Curie.from_str("MGI:12345"), Curie.from_str("MGI:12345")]) ] c = association.ConjunctiveSet.str_to_conjunctions("MGI:12345|MGI:12345") assert c == [ association.ConjunctiveSet([Curie.from_str("MGI:12345")]), association.ConjunctiveSet([Curie.from_str("MGI:12345")]) ] c = association.ConjunctiveSet.str_to_conjunctions( "MGI:12345,DOI:333|GO:987") assert c == [ association.ConjunctiveSet( [Curie.from_str("MGI:12345"), Curie.from_str("DOI:333")]), association.ConjunctiveSet([Curie.from_str("GO:987")]) ] c = association.ConjunctiveSet.str_to_conjunctions( "part_of(MGI:123),part_of(FOO:456)|has_direct_input(BAR:987)", conjunct_element_builder=lambda u: association.ExtensionUnit.from_str( u)) assert c == [ association.ConjunctiveSet([ association.ExtensionUnit(Curie.from_str("BFO:0000050"), Curie.from_str("MGI:123")), association.ExtensionUnit(Curie.from_str("BFO:0000050"), Curie.from_str("FOO:456")) ]), association.ConjunctiveSet([ association.ExtensionUnit(Curie.from_str("GOREL:0000752"), Curie.from_str("BAR:987")) ]) ] c = association.ConjunctiveSet.str_to_conjunctions( "HECK_NO,part_of(FOO:456)|has_direct_input(BAR:987)", conjunct_element_builder=lambda u: association.ExtensionUnit.from_str( u)) assert c == association.Error("HECK_NO")
def make_conjunctions(extension: List) -> association.ExtensionConjunctions: extension_units = [] # type: List[association.ExtensionUnit] for unit in extension: extension_units.append( association.ExtensionUnit(unit["relation"], unit["term"])) return association.ExtensionConjunctions(frozenset(extension_units))
def make_keys_from_gaf(gaf: List[str]) -> List[AnnotationKey]: term = curie_util.expand_uri(gaf[4], cmaps=[prefix_context]) relation = aspect_relation_map[gaf[8]] taxon = "http://purl.obolibrary.org/obo/NCBITaxon_{}".format( gaf[12].split("|")[0].split(":")[1]) extension = gaf[15] annotation_keys = [] # type: List[AnnotationKey] for conjunction in extension.split("|"): # conjunction is foo(bar),hello(world) conjunctions = [] # type: List[association.ExtensionUnit] for extension_unit in conjunction.split(","): # extension_unit is foo(bar) found_rel = relation_tuple.match(extension_unit) if found_rel: rel_label, filler = found_rel.groups() ext_relation = lookup_relation(rel_label) # type: Uri fill_id = curie_util.expand_uri(filler, cmaps=[prefix_context ]) # type: Uri extension_unit = association.ExtensionUnit( ext_relation, fill_id) # type: association.ExtensionUnit # Append the extensions unit to the list of conjunctions conjunctions.append(extension_unit) extension_conjunction = association.ExtensionConjunctions( frozenset(conjunctions)) # Build the Key now annotation_keys.append( AnnotationKey(RelationTo(relation, term), taxon, extension_conjunction)) return annotation_keys
def test_object_extensions(): p = GafParser() assoc_result = p.parse_line("PomBase\tSPAC25B8.17\typf1\t\tGO:0000007\tGO_REF:0000024\tISO\tSGD:S000001583\tC\tintramembrane aspartyl protease of the perinuclear ER membrane Ypf1 (predicted)\tppp81\tprotein\ttaxon:4896\t20181024\tPomBase\tpart_of(X:1)\tUniProtKB:P12345") print(p.report.to_markdown()) assert len(assoc_result.associations[0].object_extensions) > 0 object_extensions = [ association.ConjunctiveSet([ association.ExtensionUnit(association.Curie("BFO", "0000050"), association.Curie("X", "1")) ]) ] assert assoc_result.associations[0].object_extensions == object_extensions
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 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 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)