def convert_bound_block(self, parsing_results): pr_copy = parsing_results[:] while len(pr_copy) > 0: # bond resource bond_res = URIRef(self._resource_uri_prefix + 'bond' + str(self._bond_ctr)) self._bond_ctr += 1 # first atom number first_atom_nr = pr_copy.pop(0) first_atom = URIRef(self._resource_uri_prefix + str(self._res_cntr) + '/atom' + first_atom_nr) # second atom number second_atom_nr = pr_copy.pop(0) second_atom = URIRef(self._resource_uri_prefix + str(self._res_cntr) + '/atom' + second_atom_nr) self._g.add((first_atom, self.prop_has_binding_with, second_atom)) self._g.add((bond_res, self.prop_first_bound_atom, first_atom)) self._g.add((bond_res, self.prop_second_bound_atom, second_atom)) # bond type bond_type = bond_type_mapping[pr_copy.pop(0)] bond_cls = self._get_bond_cls_uri(bond_type) self._g.add((bond_res, RDF.term('type'), bond_cls)) # bond stereo if bond_type in bond_stereo_mapping: bond_isomerism = bond_stereo_mapping[bond_type][pr_copy.pop(0)] bond_isomerism_cls = self._get_cls_uri( self._bond_stereo_to_cls_local_part, bond_isomerism) self._g.add((bond_res, RDF.term('type'), bond_isomerism_cls)) else: # skip (values are all 0 in NCTRER dataset) pr_copy.pop(0) # not used pr_copy.pop(0) # bond topology bond_topology = bond_topology_mapping[pr_copy.pop(0)] bond_topology_cls = self._get_cls_uri( self._bond_topology_to_cls_local_part, bond_topology) for trpl in self._build_has_some( bond_res, self.prop_has_topology, bond_topology_cls): self._g.add(trpl) # reacting center status rc_status = reacting_center_status_mapping[pr_copy.pop(0)] rc_status_cls = self._get_cls_uri( self._reacting_center_status_to_cls_local_part, rc_status) for trpl in self._build_has_some( bond_res, self.prop_has_rc_status, rc_status_cls): self._g.add(trpl)
def _build_has_some(self, resource, prop, cls): tmp_graph = Graph() restr_res = BNode() tmp_graph.add((resource, RDF.term('type'), restr_res)) tmp_graph.add((restr_res, RDF.term('type'), OWL.term('Restriction'))) tmp_graph.add((restr_res, OWL.term('onProperty'), prop)) tmp_graph.add((restr_res, OWL.term('someValuesFrom'), cls)) return tmp_graph
def sparql_query(model, query_filename, output_format="text"): """Execute sparql query from file""" logger.info("Opening: %s" % (query_filename, )) query_body = open(query_filename, "r").read() query = RDF.SPARQLQuery(query_body) results = query.execute(model) if output_format == "html": html_query_results(results) else: display_query_results(results)
def finalize_sdf_items(self): # ontological axioms for prop, dtype in self._props.items(): self._g.add((prop, RDF.term('type'), OWL.term('DatatypeProperty'))) self._g.add((prop, RDFS.term('domain'), self.cls_molecule)) self._g.add((prop, RDFS.term('range'), dtype)) # the actual data for prop, data in self._props_data.items(): dtype = self._props[prop] for subj, val in data: self._g.add((subj, prop, Literal(val, None, dtype)))
def convert_counts_line(self, parsing_results): """ (Pdb) parsing_results (['20', '22', '0', '0', '0', '0', '0', '0', '0', '0', '1', 'V2000'], {}) """ # since this is called firs, a new RDF resource is created which will # have all the information attached self._curr_res = URIRef(self._resource_uri_prefix + str(self._res_cntr)) self._res_cntr += 1 self._g.add((self._curr_res, RDF.term('type'), self.cls_molecule)) num_atoms = parsing_results[0] num_bonds = parsing_results[1] num_atom_lists = parsing_results[2] molecule_is_chiral = 'true' if parsing_results[4] == 1 else 'false' # number of atoms self._g.add(( self._curr_res, self.prop_num_atoms, Literal(num_atoms, None, self.xsd_nnint) )) # number of bounds self._g.add(( self._curr_res, self.prop_num_bounds, Literal(num_bonds, None, self.xsd_nnint) )) # number of atom lists self._g.add(( self._curr_res, self.prop_num_atom_lists, Literal(num_atom_lists, None, self.xsd_nnint) )) # molecule is chiral self._g.add(( self._curr_res, self.prop_molec_is_chiral, Literal(molecule_is_chiral, None, self.xsd_bool) ))
def get_jsonld_context() -> List[dict]: """ Get JSON-LD context for the whole namespace. Ignores namespaces in _internal. English language only. Returns: List[dict]. Example below. ``` context = [ {"@foaf": "http://xmlns.com/foaf/0.1/", "@language": "en"}, {"@sdo": "https://schema.org/", "@language": "en"}, {"@owl": "http://www.w3.org/2002/07/owl#", "@language": "en"}, {"@xsd": "http://www.w3.org/2001/XMLSchema#", "@language": "en"}, {"@wd": "http://www.wikidata.org/entity/", "@language": "en"}, {"@wdt": "http://www.wikidata.org/prop/direct/", "@language": "en"}, {"@prov": "http://www.w3.org/ns/prov#", "@language": "en"}, {"@rdfs": "http://www.w3.org/2000/01/rdf-schema#", "@language": "en"}, {"@skos": "http://www.w3.org/2004/02/skos/core#", "@language": "en"}, ] ``` """ context = [ { "@xsd": XSD.__str__(), "@language": "en" }, { "@foaf": FOAF.__str__(), "@language": "en" }, { "@owl": OWL.__str__(), "@language": "en" }, { "@rdf": RDF.__str__(), "@language": "en" }, { "@rdfs": RDFS.__str__(), "@language": "en" }, { "@prov": PROV.__str__(), "@language": "en" }, { "@sdo": SDO.__str__(), "@language": "en" }, { "@skos": SKOS.__str__(), "@language": "en" }, { "@wd": WD.__str__(), "@language": "en" }, { "@wdt": WDT.__str__(), "@language": "en" }, { "@hc": HC.__str__(), "@language": "en" }, ] return context
# -*- coding: utf-8 -*- """ https://www.w3.org/TR/shacl/#core-components-value-type """ import rdflib from datetime import date, time, datetime from rdflib.term import Literal from rdflib.namespace import RDF, XSD from pyshacl.constraints.constraint_component import ConstraintComponent from pyshacl.consts import SH, RDFS_subClassOf, RDF_type,\ SH_IRI, SH_BlankNode, SH_Literal, SH_IRIOrLiteral, SH_BlankNodeOrIRI,\ SH_BlankNodeORLiteral from pyshacl.errors import ConstraintLoadError RDF_langString = RDF.term('langString') XSD_string = XSD.term('string') XSD_integer = XSD.term('integer') XSD_float = XSD.term('float') XSD_boolean = XSD.term('boolean') XSD_date = XSD.term('date') XSD_time = XSD.term('time') XSD_dateTime = XSD.term('dateTime') SH_class = SH.term('class') SH_datatype = SH.term('datatype') SH_nodeKind = SH.term('nodeKind') SH_ClassConstraintComponent = SH.term('ClassConstraintComponent') SH_DatatypeConstraintComponent = SH.term('DatatypeConstraintComponent') SH_NodeKindConstraintComponent = SH.term('NodeKindConstraintComponent')
ASGS_CAT = Namespace("http://linked.data.gov.au/def/asgs-cat/") ASGS_ID = Namespace("http://linked.data.gov.au/def/asgs/id#") GEO_Geometry = GEO.term('Geometry') GEO_Feature = GEO.term('Feature') GEO_hasGeometry = GEO.term('hasGeometry') GEO_coordinateDimension = GEO.term('coordinateDimension') GEO_dimension = GEO.term('dimension') # topological dimension. GEO_spatialDimension = GEO.term('spatialDimension') # overrides coordinateDimension GEO_isEmpty = GEO.term('isEmpty') GEO_isSimple = GEO.term('isSimple') GEO_hasDefaultGeometry = GEO.term('hasDefaultGeometry') GEO_within = GEO.term('sfWithin') GEO_contains = GEO.term('sfContains') GEOX_inCRS = GEOX.term('inCRS') RDF_a = RDF.term('type') def chunks(source, length): """Yield successive n-sized chunks from l.""" source_len = len(source) if (source_len % length) != 0: raise ValueError("Cannot do chunks.") for i in range(0, source_len, length): yield source[i:i + length] AsgsWfsTypeTuple = namedtuple('AsgsWfsType', ['service', 'typename', 'propertyname']) class AsgsWfsType(AsgsWfsTypeTuple): __slots__ = () def populate_string(self, string, **kwargs):
def finalize_atom_block_conversion(self): atom_cntr = 1 for entry in self._curr_atm_blck: atom_res = URIRef('%s/atom%i' % (str(self._curr_res), atom_cntr)) self._g.add((atom_res, RDF.term('type'), self.cls_atom)) # atom self._g.add(( self._curr_res, URIRef(self._ont_uri_prefix + 'atom'), atom_res )) # atom number self._g.add(( atom_res, self.prop_atom_number, Literal(atom_cntr, None, self.xsd_nnint) )) # atom coords X self._g.add(( atom_res, self.prop_coord_x, Literal(entry[self._atom_coords_x_str], None, self.xsd_double) )) # atom coords Y self._g.add(( atom_res, self.prop_coord_y, Literal(entry[self._atom_coords_y_str], None, self.xsd_double) )) # atom coords Z self._g.add(( atom_res, self.prop_coord_z, Literal(entry[self._atom_coords_z_str], None, self.xsd_double) )) # atom symbol res_atom_symbol = URIRef( self._resource_uri_prefix + 'atom/' + entry[self._atom_symbol_str]) self._g.add( (res_atom_symbol, RDF.term('type'), self.cls_atom_symbol)) self._g.add(( atom_res, self.prop_atom_symbol, res_atom_symbol )) # mass difference self._g.add(( atom_res, self.prop_mass_difference, Literal(entry[self._mass_diff_str], None, self.xsd_double) )) # charge self._g.add(( atom_res, self.prop_charge, Literal(entry[self._charge_str], None, self.xsd_int) )) # atom stereo parity if entry.get(self._atom_stereo_parity_str) is not None: self._g.add(( atom_res, RDF.term('type'), URIRef(self._ont_uri_prefix + entry[self._atom_stereo_parity_str]) )) # hydrogen count if entry.get(self._hydrogen_count_plus_1_str) is not None: self._g.add(( atom_res, self.prop_hydrogen_count, URIRef(self._resource_uri_prefix + entry[self._hydrogen_count_plus_1_str].lower()) )) # valence if entry.get(self._valence_str) is not None: self._g.add(( atom_res, self.prop_valence, Literal(entry[self._valence_str], None, self.xsd_nnint) )) # H0 designator if entry.get(self._h0_designator_str) is not None: self._g.add(( atom_res, self.prop_h_atoms_allowed, Literal(entry[self._h0_designator_str], None, self.xsd_bool) )) # atom-atom mapping number self._g.add(( atom_res, self.prop_atom_atom_mapping_nr, Literal(entry[self._atom_atom_mapping_number_str], None, self.xsd_nnint) )) atom_cntr += 1
def _init_ontology(self): # ---------------------- basic vocabulary elements -------------------- self.xsd_nnint = XSD.term('nonNegativeInteger') self.xsd_int = XSD.term('integer') self.xsd_bool = XSD.term('boolean') self.xsd_double = XSD.term('double') a = RDF.term('type') rdfs_dom = RDFS.term('domain') rdfs_rnge = RDFS.term('range') rdfs_subcls_of = RDFS.term('subClassOf') owl_class = OWL.term('Class') owl_dtype_prop = OWL.term('DatatypeProperty') owl_obj_prop = OWL.term('ObjectProperty') # --------------------------- basic classes --------------------------- # dllont:Molecule self.cls_molecule = URIRef(self._ont_uri_prefix + 'Molecule') self._g.add((self.cls_molecule, a, owl_class)) # dllont:Atom self.cls_atom = URIRef(self._ont_uri_prefix + 'Atom') self._g.add((self.cls_atom, a, owl_class)) # dllont:AtomSymbol self.cls_atom_symbol = URIRef(self._ont_uri_prefix + 'AtomSymbol') self._g.add((self.cls_atom_symbol, a, owl_class)) # ----------------- atom stereo parity class hierarchy ---------------- # dllont:AtomParity cls_atom_parity = URIRef(self._ont_uri_prefix + 'AtomParity') self._g.add((cls_atom_parity, a, owl_class)) # dllont:AtomParityNotStereo, dllont:AtomParityOdd, # dllont:AtomParityEven, dllont:AtomParityEitherOrUnmarkedStereoCenter for val in atom_stereo_parity_mapping.values(): cls = self._get_cls_uri( self._atom_stereo_parity_type_to_cls_local_part, val) self._g.add((cls, a, owl_class)) self._g.add((cls, rdfs_subcls_of, cls_atom_parity)) # ----------------- hydrogen count resources and class ---------------- # dllont:HydrogenCount self.cls_hydrogen_count = \ URIRef(self._ont_uri_prefix + 'HydrogenCount') self._g.add((self.cls_hydrogen_count, a, owl_class)) for val in hydrogen_count_mapping.values(): if val is not None: hc_res = URIRef(self._resource_uri_prefix + val.lower()) self._g.add((hc_res, a, self.cls_hydrogen_count)) # ------------------------ bond class hierarchy ----------------------- # dllont:Bond self.cls_bond = URIRef(self._ont_uri_prefix + 'Bond') self._g.add((self.cls_bond, a, owl_class)) # dllont:SingleBond, dllont:DoubleBond, dllont:TripleBond, # dllont:AromaticBond, dllont:SingleOrDoubleBond, # dllont:SingleOrAromaticBond, dllont:DoubleOrAromaticBond for val in bond_type_mapping.values(): bond_cls = self._get_bond_cls_uri(val) self._g.add((bond_cls, a, owl_class)) for sdf_type in self._bond_type_to_cls_local_part[val][1]: super_cls = self._get_bond_cls_uri(sdf_type) self._g.add((bond_cls, rdfs_subcls_of, super_cls)) # ------------------- bond isomerism class hierarchy ------------------ # dllont:NonStereoBond non_st_bond_cls = self._get_cls_uri( self._bond_stereo_to_cls_local_part, 'Not stereo') self._g.add((non_st_bond_cls, a, owl_class)) self._g.add((non_st_bond_cls, rdfs_subcls_of, self.cls_bond)) # dllont:SingleBondEitherUpOrDownStereochemistry either_up_or_down_cls = self._get_cls_uri( self._bond_stereo_to_cls_local_part, 'Either') self._g.add((either_up_or_down_cls, a, owl_class)) self._g.add(( either_up_or_down_cls, rdfs_subcls_of, self._get_bond_cls_uri('Single') )) # dllont:SingleBondUpStereochemistry up_stereo_cls = self._get_cls_uri( self._bond_stereo_to_cls_local_part, 'Up') self._g.add((up_stereo_cls, a, owl_class)) self._g.add((up_stereo_cls, rdfs_subcls_of, either_up_or_down_cls)) # dllont:SingleBondDownStereochemistry down_stereo_cls = self._get_cls_uri( self._bond_stereo_to_cls_local_part, 'Down') self._g.add((down_stereo_cls, a, owl_class)) self._g.add((down_stereo_cls, rdfs_subcls_of, either_up_or_down_cls)) cls_double_bond = self._get_bond_cls_uri('Double') # dllont:DoubleBondDeriveCisOrTransIsomerismFromXYZCoords derive_iso_cls = self._get_cls_uri( self._bond_stereo_to_cls_local_part, 'Use x-, y-, z-coords from atom block to determine cis or trans') self._g.add((derive_iso_cls, a, owl_class)) self._g.add((derive_iso_cls, rdfs_subcls_of, cls_double_bond)) # dllont:DoubleBondEitherCisOrTransIsomerism cis_or_trans_cls = self._get_cls_uri( self._bond_stereo_to_cls_local_part, 'Either cis or trans double bond') self._g.add((cis_or_trans_cls, a, owl_class)) self._g.add((cis_or_trans_cls, rdfs_subcls_of, cls_double_bond)) # -------------------------- topology classes ------------------------- # dllont:BondTopology topology_cls = URIRef(self._ont_uri_prefix + 'BondTopology') self._g.add((topology_cls, a, owl_class)) # dllont:EitherRingOrChainTopology either_topo_cls = self._get_cls_uri( self._bond_topology_to_cls_local_part, 'Either') self._g.add((either_topo_cls, a, owl_class)) self._g.add((either_topo_cls, rdfs_subcls_of, topology_cls)) # dllont:RingTopology ring_topo_cls = self._get_cls_uri( self._bond_topology_to_cls_local_part, 'Ring') self._g.add((ring_topo_cls, a, owl_class)) self._g.add((ring_topo_cls, rdfs_subcls_of, either_topo_cls)) # dllont:ChainTopology chain_topo_cls = self._get_cls_uri( self._bond_topology_to_cls_local_part, 'Chain') self._g.add((chain_topo_cls, a, owl_class)) self._g.add((chain_topo_cls, rdfs_subcls_of, either_topo_cls)) # --------------- reacting center status class hierarchy -------------- # dllont:ReactingCenterStatus react_center_status_cls = URIRef( self._ont_uri_prefix + 'ReactingCenterStatus') self._g.add((react_center_status_cls, a, owl_class)) # dllont:Unmarked react_unmarked_cls = self._get_cls_uri( self._reacting_center_status_to_cls_local_part, 'unmarked') self._g.add((react_unmarked_cls, a, owl_class)) self._g.add( (react_unmarked_cls, rdfs_subcls_of, react_center_status_cls)) # dllont:ACenter react_a_center_cls = self._get_cls_uri( self._reacting_center_status_to_cls_local_part, 'a center') self._g.add((react_a_center_cls, a, owl_class)) self._g.add( (react_a_center_cls, rdfs_subcls_of, react_center_status_cls)) # dllont:NotACenter react_not_a_center_cls = self._get_cls_uri( self._reacting_center_status_to_cls_local_part, 'not a center') self._g.add((react_not_a_center_cls, a, owl_class)) self._g.add( (react_not_a_center_cls, rdfs_subcls_of, react_center_status_cls)) self._g.add(( react_a_center_cls, OWL.term('disjointWith'), react_not_a_center_cls )) # dllont:NoChange react_no_change_cls = self._get_cls_uri( self._reacting_center_status_to_cls_local_part, 'no change') self._g.add((react_no_change_cls, a, owl_class)) self._g.add( (react_no_change_cls, rdfs_subcls_of, react_center_status_cls)) # FIXME: add class intersections # dllont:BondMadeOrBroken react_bond_made_or_broken_cls = self._get_cls_uri( self._reacting_center_status_to_cls_local_part, 'bond made/broken') self._g.add((react_bond_made_or_broken_cls, a, owl_class)) self._g.add(( react_bond_made_or_broken_cls, rdfs_subcls_of, react_center_status_cls )) # dllont:BondOrderChanges react_bond_order_change_cls = self._get_cls_uri( self._reacting_center_status_to_cls_local_part, 'bond order changes') self._g.add((react_bond_order_change_cls, a, owl_class)) self._g.add(( react_bond_order_change_cls, rdfs_subcls_of, react_center_status_cls )) # dllont:BondMadeOrBrokenAndBondOrderChanges react_bmob_and_boc_cls = self._get_cls_uri( self._reacting_center_status_to_cls_local_part, 'bond made/broken + bond order changes') self._g.add((react_bmob_and_boc_cls, a, owl_class)) self._g.add(( react_bmob_and_boc_cls, rdfs_subcls_of, react_bond_made_or_broken_cls )) self._g.add(( react_bmob_and_boc_cls, rdfs_subcls_of, react_bond_order_change_cls )) # dllont:BondMadeOrBrokenAndACenter react_bmob_and_a_center_cls = self._get_cls_uri( self._reacting_center_status_to_cls_local_part, 'bond made/broken + a center') self._g.add((react_bmob_and_a_center_cls, a, owl_class)) self._g.add(( react_bmob_and_a_center_cls, rdfs_subcls_of, react_bond_made_or_broken_cls )) self._g.add(( react_bmob_and_a_center_cls, rdfs_subcls_of, react_a_center_cls )) # dllont:BondMadeOrBrokenAndBondOrderChangesAndACenter react_bmob_and_boc_and_a_center_cls = self._get_cls_uri( self._reacting_center_status_to_cls_local_part, 'bond made/broken + bond order changes + a center') self._g.add((react_bmob_and_boc_and_a_center_cls, a, owl_class)) self._g.add(( react_bmob_and_boc_and_a_center_cls, rdfs_subcls_of, react_bmob_and_boc_cls )) self._g.add(( react_bmob_and_boc_and_a_center_cls, rdfs_subcls_of, react_bmob_and_a_center_cls )) self._g.add(( react_bmob_and_boc_and_a_center_cls, rdfs_subcls_of, react_a_center_cls )) # ------------------------ property definitions ----------------------- # dllont:number_of_atoms self.prop_num_atoms = \ URIRef(self._ont_uri_prefix + 'number_of_atoms') self._g.add((self.prop_num_atoms, a, owl_dtype_prop)) self._g.add((self.prop_num_atoms, rdfs_dom, self.cls_molecule)) self._g.add((self.prop_num_atoms, rdfs_rnge, self.xsd_nnint)) # dllont:number_of_bounds self.prop_num_bounds = \ URIRef(self._ont_uri_prefix + 'number_of_bounds') self._g.add((self.prop_num_bounds, a, owl_dtype_prop)) self._g.add((self.prop_num_bounds, rdfs_dom, self.cls_molecule)) self._g.add((self.prop_num_bounds, rdfs_rnge, self.xsd_nnint)) # dllont:number_of_atom_lists self.prop_num_atom_lists = URIRef( self._ont_uri_prefix + 'number_of_atom_lists') self._g.add((self.prop_num_atom_lists, a, owl_dtype_prop)) self._g.add((self.prop_num_atom_lists, rdfs_dom, self.cls_molecule)) self._g.add((self.prop_num_atom_lists, rdfs_rnge, self.xsd_nnint)) # dllont:molecule_is_chiral self.prop_molec_is_chiral = URIRef( self._ont_uri_prefix + 'molecule_is_chiral') self._g.add((self.prop_molec_is_chiral, a, owl_dtype_prop)) self._g.add((self.prop_molec_is_chiral, rdfs_dom, self.cls_molecule)) self._g.add((self.prop_molec_is_chiral, rdfs_rnge, self.xsd_bool)) # dllont:atom self.prop_atom = URIRef(self._ont_uri_prefix + 'atom') self._g.add((self.prop_atom, a, owl_obj_prop)) self._g.add((self.prop_atom, rdfs_dom, self.cls_molecule)) self._g.add((self.prop_atom, rdfs_rnge, self.cls_atom)) # dllont:atom_number self.prop_atom_number = URIRef(self._ont_uri_prefix + 'atom_number') self._g.add((self.prop_atom_number, a, owl_dtype_prop)) self._g.add((self.prop_atom_number, rdfs_dom, self.cls_atom)) self._g.add((self.prop_atom_number, rdfs_rnge, self.xsd_nnint)) # dllont:atom_coordinate_x self.prop_coord_x = URIRef(self._ont_uri_prefix + 'atom_coordinate_x') self._g.add((self.prop_coord_x, a, owl_dtype_prop)) self._g.add((self.prop_coord_x, rdfs_dom, self.cls_atom)) self._g.add((self.prop_coord_x, rdfs_rnge, self.xsd_double)) # dllont:atom_coordinate_y self.prop_coord_y = URIRef(self._ont_uri_prefix + 'atom_coordinate_y') self._g.add((self.prop_coord_y, a, owl_dtype_prop)) self._g.add((self.prop_coord_y, rdfs_dom, self.cls_atom)) self._g.add((self.prop_coord_y, rdfs_rnge, self.xsd_double)) # dllont:atom_coordinate_z self.prop_coord_z = URIRef(self._ont_uri_prefix + 'atom_coordinate_z') self._g.add((self.prop_coord_z, a, owl_dtype_prop)) self._g.add((self.prop_coord_z, rdfs_dom, self.cls_atom)) self._g.add((self.prop_coord_z, rdfs_rnge, self.xsd_double)) # dllont:atom_symbol self.prop_atom_symbol = URIRef(self._ont_uri_prefix + 'atom_symbol') self._g.add((self.prop_atom_symbol, a, owl_obj_prop)) self._g.add((self.prop_atom_symbol, rdfs_dom, self.cls_atom)) self._g.add((self.prop_atom_symbol, rdfs_rnge, self.cls_atom_symbol)) # dllont:mass_difference self.prop_mass_difference = URIRef( self._ont_uri_prefix + 'mass_difference') self._g.add((self.prop_mass_difference, a, owl_dtype_prop)) self._g.add((self.prop_mass_difference, rdfs_dom, self.cls_atom)) self._g.add((self.prop_mass_difference, rdfs_rnge, self.xsd_double)) # dllont:charge self.prop_charge = URIRef(self._ont_uri_prefix + 'charge') self._g.add((self.prop_charge, a, owl_dtype_prop)) self._g.add((self.prop_charge, rdfs_dom, self.cls_atom)) self._g.add((self.prop_charge, rdfs_rnge, self.xsd_int)) # dllont:hydrogen_count self.prop_hydrogen_count = URIRef( self._ont_uri_prefix + 'hydrogen_count') self._g.add((self.prop_hydrogen_count, a, owl_obj_prop)) self._g.add((self.prop_hydrogen_count, rdfs_dom, self.cls_atom)) self._g.add( (self.prop_hydrogen_count, rdfs_rnge, self.cls_hydrogen_count)) # dllont:valence self.prop_valence = URIRef(self._ont_uri_prefix + 'valence') self._g.add((self.prop_valence, a, owl_dtype_prop)) self._g.add((self.prop_valence, rdfs_dom, self.cls_atom)) self._g.add((self.prop_valence, rdfs_rnge, self.xsd_nnint)) # dllont:h_atoms_allowed self.prop_h_atoms_allowed = URIRef( self._ont_uri_prefix + 'h_atoms_allowed') self._g.add((self.prop_h_atoms_allowed, a, owl_dtype_prop)) self._g.add((self.prop_h_atoms_allowed, rdfs_dom, self.cls_atom)) self._g.add((self.prop_h_atoms_allowed, rdfs_rnge, self.xsd_bool)) # dllont:atom-atom_mapping_number self.prop_atom_atom_mapping_nr = URIRef( self._ont_uri_prefix + 'atom-atom_mapping_number') self._g.add((self.prop_atom_atom_mapping_nr, a, owl_dtype_prop)) self._g.add((self.prop_atom_atom_mapping_nr, rdfs_dom, self.cls_atom)) self._g.add( (self.prop_atom_atom_mapping_nr, rdfs_rnge, self.xsd_nnint)) # dllont:has_binding_with self.prop_has_binding_with = URIRef( self._ont_uri_prefix + 'has_binding_with') self._g.add(( self.prop_has_binding_with, a, URIRef(OWL.term('SymmetricProperty')) )) self._g.add((self.prop_has_binding_with, rdfs_dom, self.cls_atom)) self._g.add((self.prop_has_binding_with, rdfs_rnge, self.cls_atom)) # dllont:first_bound_atom self.prop_first_bound_atom = URIRef( self._ont_uri_prefix + 'first_bound_atom') self._g.add((self.prop_first_bound_atom, a, owl_obj_prop)) self._g.add((self.prop_first_bound_atom, rdfs_dom, self.cls_bond)) self._g.add((self.prop_first_bound_atom, rdfs_rnge, self.cls_atom)) # dllont:second_bound_atom self.prop_second_bound_atom = URIRef( self._ont_uri_prefix + 'second_bound_atom') self._g.add((self.prop_second_bound_atom, a, owl_obj_prop)) self._g.add((self.prop_second_bound_atom, rdfs_dom, self.cls_bond)) self._g.add((self.prop_second_bound_atom, rdfs_rnge, self.cls_atom)) # dllont:has_topology self.prop_has_topology = URIRef(self._ont_uri_prefix + 'has_topology') self._g.add((self.prop_has_topology, a, owl_obj_prop)) self._g.add((self.prop_has_topology, rdfs_dom, self.cls_bond)) self._g.add((self.prop_has_topology, rdfs_rnge, topology_cls)) # dllont:has_reacting_center_status self.prop_has_rc_status = URIRef( self._ont_uri_prefix + 'has_reacting_center_status') self._g.add((self.prop_has_rc_status, a, owl_obj_prop)) self._g.add((self.prop_has_rc_status, rdfs_dom, self.cls_bond)) self._g.add( (self.prop_has_rc_status, rdfs_rnge, react_center_status_cls))