def node_element_start(self, name, qname, attrs):
name, atts = self.convert(name, qname, attrs)
current = self.current
absolutize = self.absolutize
# Cheap hack so 2to3 doesn't turn it into __next__
next = getattr(self, 'next')
next.start = self.property_element_start
next.end = self.property_element_end
if name in NODE_ELEMENT_EXCEPTIONS:
self.error("Invalid node element URI: %s" % name)
if RDF.ID in atts:
if RDF.about in atts or RDF.nodeID in atts:
self.error("Can have at most one of rdf:ID, rdf:about, and rdf:nodeID")
id = atts[RDF.ID]
if not is_ncname(id):
self.error("rdf:ID value is not a valid NCName: %s" % id)
subject = absolutize("#%s" % id)
if subject in self.ids:
self.error("two elements cannot use the same ID: '%s'" % subject)
self.ids[subject] = 1 # IDs can only appear once within a document
elif RDF.nodeID in atts:
if RDF.ID in atts or RDF.about in atts:
self.error("Can have at most one of rdf:ID, rdf:about, and rdf:nodeID")
nodeID = atts[RDF.nodeID]
if not is_ncname(nodeID):
self.error("rdf:nodeID value is not a valid NCName: %s" % nodeID)
if self.preserve_bnode_ids is False:
if nodeID in self.bnode:
subject = self.bnode[nodeID]
else:
subject = BNode()
self.bnode[nodeID] = subject
else:
subject = BNode(nodeID)
elif RDF.about in atts:
if RDF.ID in atts or RDF.nodeID in atts:
self.error("Can have at most one of rdf:ID, rdf:about, and rdf:nodeID")
subject = absolutize(atts[RDF.about])
else:
subject = BNode()
if name!=RDF.Description: # S1
self.store.add((subject, RDF.type, absolutize(name)))
language = current.language
for att in atts:
if not att.startswith(str(RDFNS)):
predicate = absolutize(att)
try:
object = Literal(atts[att], language)
except Error, e:
self.error(e.msg)
elif att==RDF.type: #S2
predicate = RDF.type
object = absolutize(atts[RDF.type])
def uri_for(self, uri_or_curie: Any) -> URIRef:
"""
Map a curie or URI into a full URIRef.
:param uri_or_curie: "NCNAME ':' suffix" or plain URI
:return: Corresponding URI
"""
uri_or_curie_str = str(uri_or_curie)
if '://' in uri_or_curie_str:
return URIRef(uri_or_curie_str)
if ':' in uri_or_curie_str:
prefix, local = str(uri_or_curie_str).split(':', 1)
if not prefix:
prefix = self._default_key
elif not is_ncname(prefix):
raise ValueError(
f"{TypedNode.yaml_loc(uri_or_curie)}Not a valid CURIE: {uri_or_curie_str}"
)
else:
prefix, local = self._base_key, uri_or_curie_str
if prefix not in self:
raise ValueError(
f"{TypedNode.yaml_loc(uri_or_curie)}Unknown CURIE prefix: {prefix}"
)
return URIRef(self.join(self[prefix], local))
def clean_prefix(self):
"""
Validates the prefix
"""
if self.instance.fixed:
return self.instance.prefix
prefix = self.cleaned_data['prefix']
if not namespace.is_ncname(prefix):
raise forms.ValidationError("This is an invalid prefix")
return prefix
def clean_prefix(self):
"""
Validates the prefix
"""
if self.instance.fixed:
return self.instance.prefix
prefix = self.cleaned_data['prefix']
if not namespace.is_ncname(prefix):
raise forms.ValidationError("This is an invalid prefix")
return prefix
def add_prefixmap(self, map_name: str, include_defaults: bool = True) -> None:
"""
Add a prefixcommons map. Only prefixes that have not been previously defined are added.
:param map_name: prefixcommons map name
:param include_defaults: if True, take defaults from the map.
:return:
"""
for k, v in curie_util.read_biocontext(map_name).items():
if not k:
if include_defaults and not self._default:
self._default = v
elif k not in self:
if is_ncname(k):
self[k] = v
else:
logging.getLogger('Namespaces').info(f"biocontext map {map_name} has illegal prefix: {k}")
pass
def __setitem__(self, key, value):
if key == '_':
if not value:
if self._empty_bnode not in self._bnodes:
self._bnodes[self._empty_bnode] = BNode()
elif value in self._bnodes:
raise ValueError(f"BNode {value} is already mapped to {self[self._bnodes[value]]}")
else:
target_bnode = BNode()
self._bnodes[value] = target_bnode
super().__setitem__(value, target_bnode)
elif is_ncname(key):
v = Namespace(str(value))
if key in self:
if self[key] != v:
logging.getLogger('Namespaces').\
warning(f"{key} namespace is already mapped to {self[key]} - Mapping to {v} ignored")
else:
super().__setitem__(key, v)
else:
raise ValueError(f"Invalid NCName: {key}")
def is_valid(cls, v: str) -> bool:
return is_ncname(v) if v else True # Empty is default name
def property_element_start(self, name, qname, attrs):
name, atts = self.convert(name, qname, attrs)
current = self.current
absolutize = self.absolutize
# Cheap hack so 2to3 doesn't turn it into __next__
next = getattr(self, 'next')
object = None
current.data = None
current.list = None
if not name.startswith(str(RDFNS)):
current.predicate = absolutize(name)
elif name==RDF.li:
current.predicate = current.next_li()
elif name in PROPERTY_ELEMENT_EXCEPTIONS:
self.error("Invalid property element URI: %s" % name)
else:
current.predicate = absolutize(name)
id = atts.get(RDF.ID, None)
if id is not None:
if not is_ncname(id):
self.error("rdf:ID value is not a value NCName: %s" % id)
current.id = absolutize("#%s" % id)
else:
current.id = None
resource = atts.get(RDF.resource, None)
nodeID = atts.get(RDF.nodeID, None)
parse_type = atts.get(RDF.parseType, None)
if resource is not None and nodeID is not None:
self.error("Property element cannot have both rdf:nodeID and rdf:resource")
if resource is not None:
object = absolutize(resource)
next.start = self.node_element_start
next.end = self.node_element_end
elif nodeID is not None:
if not is_ncname(nodeID):
self.error("rdf:nodeID value is not a valid NCName: %s" % nodeID)
if self.preserve_bnode_ids is False:
if nodeID in self.bnode:
object = self.bnode[nodeID]
else:
subject = BNode()
self.bnode[nodeID] = subject
object = subject
else:
object = subject = BNode(nodeID)
next.start = self.node_element_start
next.end = self.node_element_end
else:
if parse_type is not None:
for att in atts:
if att!=RDF.parseType and att!=RDF.ID:
self.error("Property attr '%s' now allowed here" % att)
if parse_type=="Resource":
current.subject = object = BNode()
current.char = self.property_element_char
next.start = self.property_element_start
next.end = self.property_element_end
elif parse_type=="Collection":
current.char = None
object = current.list = RDF.nil #BNode()#self.parent.subject
next.start = self.node_element_start
next.end = self.list_node_element_end
else: #if parse_type=="Literal":
# All other values are treated as Literal
# See: http://www.w3.org/TR/rdf-syntax-grammar/#parseTypeOtherPropertyElt
object = Literal("", datatype=RDF.XMLLiteral)
current.char = self.literal_element_char
current.declared = {}
next.start = self.literal_element_start
next.char = self.literal_element_char
next.end = self.literal_element_end
current.object = object
return
else:
object = None
current.char = self.property_element_char
next.start = self.node_element_start
next.end = self.node_element_end
datatype = current.datatype = atts.get(RDF.datatype, None)
language = current.language
if datatype is not None:
# TODO: check that there are no atts other than datatype and id
datatype = absolutize(datatype)
else:
for att in atts:
if not att.startswith(str(RDFNS)):
predicate = absolutize(att)
elif att in PROPERTY_ELEMENT_ATTRIBUTES:
continue
elif att in PROPERTY_ATTRIBUTE_EXCEPTIONS:
self.error("""Invalid property attribute URI: %s""" % att)
else:
predicate = absolutize(att)
if att==RDF.type:
o = URIRef(atts[att])
else:
if datatype is not None:
language = None
o = Literal(atts[att], language, datatype)
if object is None:
object = BNode()
self.store.add((object, predicate, o))
if object is None:
current.data = ""
current.object = None
else:
current.data = None
current.object = object
def property_element_start(self, name, qname, attrs):
name, atts = self.convert(name, qname, attrs)
current = self.current
absolutize = self.absolutize
# Cheap hack so 2to3 doesn't turn it into __next__
next = getattr(self, 'next')
object = None
current.data = None
current.list = None
if not name.startswith(str(RDFNS)):
current.predicate = absolutize(name)
elif name == RDF.li:
current.predicate = current.next_li()
elif name in PROPERTY_ELEMENT_EXCEPTIONS:
self.error("Invalid property element URI: %s" % name)
else:
current.predicate = absolutize(name)
id = atts.get(RDF.ID, None)
if id is not None:
if not is_ncname(id):
self.error("rdf:ID value is not a value NCName: %s" % id)
current.id = absolutize("#%s" % id)
else:
current.id = None
resource = atts.get(RDF.resource, None)
nodeID = atts.get(RDF.nodeID, None)
parse_type = atts.get(RDF.parseType, None)
if resource is not None and nodeID is not None:
self.error(
"Property element cannot have both rdf:nodeID and rdf:resource"
)
if resource is not None:
object = absolutize(resource)
next.start = self.node_element_start
next.end = self.node_element_end
elif nodeID is not None:
if not is_ncname(nodeID):
self.error("rdf:nodeID value is not a valid NCName: %s" %
nodeID)
if self.preserve_bnode_ids is False:
if nodeID in self.bnode:
object = self.bnode[nodeID]
else:
subject = BNode()
self.bnode[nodeID] = subject
object = subject
else:
object = subject = BNode(nodeID)
next.start = self.node_element_start
next.end = self.node_element_end
else:
if parse_type is not None:
for att in atts:
if att != RDF.parseType and att != RDF.ID:
self.error("Property attr '%s' now allowed here" % att)
if parse_type == "Resource":
current.subject = object = BNode()
current.char = self.property_element_char
next.start = self.property_element_start
next.end = self.property_element_end
elif parse_type == "Collection":
current.char = None
object = current.list = RDF.nil # BNode()
#self.parent.subject
next.start = self.node_element_start
next.end = self.list_node_element_end
else: # if parse_type=="Literal":
# All other values are treated as Literal
# See: http://www.w3.org/TR/rdf-syntax-grammar/
#parseTypeOtherPropertyElt
object = Literal("", datatype=RDF.XMLLiteral)
current.char = self.literal_element_char
current.declared = {XMLNS: 'xml'}
next.start = self.literal_element_start
next.char = self.literal_element_char
next.end = self.literal_element_end
current.object = object
return
else:
object = None
current.char = self.property_element_char
next.start = self.node_element_start
next.end = self.node_element_end
datatype = current.datatype = atts.get(RDF.datatype, None)
language = current.language
if datatype is not None:
# TODO: check that there are no atts other than datatype and id
datatype = absolutize(datatype)
else:
for att in atts:
if not att.startswith(str(RDFNS)):
predicate = absolutize(att)
elif att in PROPERTY_ELEMENT_ATTRIBUTES:
continue
elif att in PROPERTY_ATTRIBUTE_EXCEPTIONS:
self.error("""Invalid property attribute URI: %s""" % att)
else:
predicate = absolutize(att)
if att == RDF.type:
o = URIRef(atts[att])
else:
if datatype is not None:
language = None
o = Literal(atts[att], language, datatype)
if object is None:
object = BNode()
self.store.add((object, predicate, o))
if object is None:
current.data = ""
current.object = None
else:
current.data = None
current.object = object
def node_element_start(self, name, qname, attrs):
name, atts = self.convert(name, qname, attrs)
current = self.current
absolutize = self.absolutize
# Cheap hack so 2to3 doesn't turn it into __next__
next = getattr(self, 'next')
next.start = self.property_element_start
next.end = self.property_element_end
if name in NODE_ELEMENT_EXCEPTIONS:
self.error("Invalid node element URI: %s" % name)
if RDF.ID in atts:
if RDF.about in atts or RDF.nodeID in atts:
self.error(
"Can have at most one of rdf:ID, rdf:about, and rdf:nodeID"
)
id = atts[RDF.ID]
if not is_ncname(id):
self.error("rdf:ID value is not a valid NCName: %s" % id)
subject = absolutize("#%s" % id)
if subject in self.ids:
self.error("two elements cannot use the same ID: '%s'" %
subject)
self.ids[subject] = 1 # IDs can only appear once within a document
elif RDF.nodeID in atts:
if RDF.ID in atts or RDF.about in atts:
self.error(
"Can have at most one of rdf:ID, rdf:about, and rdf:nodeID"
)
nodeID = atts[RDF.nodeID]
if not is_ncname(nodeID):
self.error("rdf:nodeID value is not a valid NCName: %s" %
nodeID)
if self.preserve_bnode_ids is False:
if nodeID in self.bnode:
subject = self.bnode[nodeID]
else:
subject = BNode()
self.bnode[nodeID] = subject
else:
subject = BNode(nodeID)
elif RDF.about in atts:
if RDF.ID in atts or RDF.nodeID in atts:
self.error(
"Can have at most one of rdf:ID, rdf:about, and rdf:nodeID"
)
subject = absolutize(atts[RDF.about])
else:
subject = BNode()
if name != RDF.Description: # S1
self.store.add((subject, RDF.type, absolutize(name)))
language = current.language
for att in atts:
if not att.startswith(str(RDFNS)):
predicate = absolutize(att)
try:
object = Literal(atts[att], language)
except Error, e:
self.error(e.msg)
elif att == RDF.type: # S2
predicate = RDF.type
object = absolutize(atts[RDF.type])
def __init__(self, v: Optional[str] = None) -> None:
super().__init__(v)
if v and not is_ncname(v):
raise ValueError(f"{v} is not a valid NCNAME according to rdflib")
