def test2(self):
from fhirtordf.fhir.fhirmetavoc import FHIRMetaVocEntry
m = FHIRMetaVocEntry(self.fhir_ontology, "Account")
preds = m.predicates()
v = []
for name in sorted(preds.keys()):
pred = preds[name]
t = m.predicate_type(pred)
v.append((name, str(t), 'A' if m.is_atom(pred) else
'P' if m.is_primitive(t) else 'C'))
self.assertEqual([
('contained', 'http://hl7.org/fhir/Resource', 'C'),
('coverage', 'http://hl7.org/fhir/Account.CoverageComponent', 'C'),
('description', 'http://hl7.org/fhir/string', 'P'),
('extension', 'http://hl7.org/fhir/Extension', 'C'),
('guarantor', 'http://hl7.org/fhir/Account.GuarantorComponent',
'C'), ('id', 'http://hl7.org/fhir/id', 'P'),
('identifier', 'http://hl7.org/fhir/Identifier', 'C'),
('implicitRules', 'http://hl7.org/fhir/uri', 'P'),
('language', 'http://hl7.org/fhir/code', 'P'),
('meta', 'http://hl7.org/fhir/Meta', 'C'),
('modifierExtension', 'http://hl7.org/fhir/Extension', 'C'),
('name', 'http://hl7.org/fhir/string', 'P'),
('nodeRole', 'http://hl7.org/fhir/treeRoot', 'A'),
('owner', 'http://hl7.org/fhir/Reference', 'C'),
('partOf', 'http://hl7.org/fhir/Reference', 'C'),
('servicePeriod', 'http://hl7.org/fhir/Period', 'C'),
('status', 'http://hl7.org/fhir/code', 'P'),
('subject', 'http://hl7.org/fhir/Reference', 'C'),
('text', 'http://hl7.org/fhir/Narrative', 'C'),
('type', 'http://hl7.org/fhir/CodeableConcept', 'C')
], v)
def test_nostring_valuetype(self):
from fhirtordf.fhir.fhirmetavoc import FHIRMetaVocEntry
m = FHIRMetaVocEntry(self.fhir_ontology, "Account")
self.assertEqual(XSD.base64Binary,
m.primitive_datatype_nostring(FHIR.base64Binary))
self.assertEqual(XSD.boolean,
m.primitive_datatype_nostring(FHIR.boolean))
self.assertEqual(None, m.primitive_datatype_nostring(FHIR.code))
self.assertEqual(XSD.dateTime,
m.primitive_datatype_nostring(FHIR.date))
self.assertEqual(XSD.dateTime,
m.primitive_datatype_nostring(FHIR.dateTime))
self.assertEqual(XSD.decimal,
m.primitive_datatype_nostring(FHIR.decimal))
self.assertEqual(None, m.primitive_datatype_nostring(FHIR.id))
self.assertEqual(XSD.dateTime,
m.primitive_datatype_nostring(FHIR.instant))
self.assertEqual(XSD.integer,
m.primitive_datatype_nostring(FHIR.integer))
self.assertEqual(None, m.primitive_datatype_nostring(FHIR.markdown))
self.assertEqual(None, m.primitive_datatype_nostring(FHIR.oid))
self.assertEqual(XSD.positiveInteger,
m.primitive_datatype_nostring(FHIR.positiveInt))
self.assertEqual(None, m.primitive_datatype_nostring(FHIR.string))
self.assertEqual(None, m.primitive_datatype_nostring(FHIR.time))
self.assertEqual(XSD.nonNegativeInteger,
m.primitive_datatype_nostring(FHIR.unsignedInt))
self.assertEqual(None, m.primitive_datatype_nostring(FHIR.uri))
self.assertEqual(None, m.primitive_datatype_nostring(FHIR.uuid))
self.assertEqual(None, m.primitive_datatype_nostring(FHIR.Quantity))
def add_value_node(self,
subj: Node,
pred: URIRef,
val: Union[JsonObj, str, List],
valuetype: Optional[URIRef] = None) -> None:
"""
Expand val according to the range of pred and add it to the graph
:param subj: graph subject
:param pred: graph predicate
:param val: JSON representation of target object
:param valuetype: predicate type if it can't be directly determined
"""
pred_type = self._meta.predicate_type(
pred) if not valuetype else valuetype
# Transform generic resources into specific types
if pred_type == FHIR.Resource:
pred_type = FHIR[val.resourceType]
val_meta = FHIRMetaVocEntry(self._vocabulary, pred_type)
for k, p in val_meta.predicates().items():
if isinstance(val, JsonObj) and k in val:
self.add_val(subj, p, val, k)
if pred == FHIR.CodeableConcept.coding:
self.add_type_arc(subj, val)
elif k == "value" and val_meta.predicate_type(p) == FHIR.Element:
# value / Element is the wild card combination -- if there is a "value[x]" in val, emit it where the
# type comes from 'x'
for vk in val._as_dict.keys():
if vk.startswith(k):
self.add_val(subj, FHIR['Extension.' + vk], val, vk,
self._meta.value_predicate_to_type(vk))
else:
# Can have an extension only without a primary value
self.add_extension_val(subj, val, k, p)
def test1(self):
from fhirtordf.fhir.fhirmetavoc import FHIRMetaVocEntry
m = FHIRMetaVocEntry(self.fhir_ontology, "Account")
self.assertEqual({
'active': rdflib.term.URIRef('http://hl7.org/fhir/Account.active'),
'contained': rdflib.term.URIRef('http://hl7.org/fhir/DomainResource.contained'),
'coverage': rdflib.term.URIRef('http://hl7.org/fhir/Account.coverage'),
'description': rdflib.term.URIRef('http://hl7.org/fhir/Account.description'),
'extension': rdflib.term.URIRef('http://hl7.org/fhir/DomainResource.extension'),
'guarantor': rdflib.term.URIRef('http://hl7.org/fhir/Account.guarantor'),
'id': rdflib.term.URIRef('http://hl7.org/fhir/Resource.id'),
'identifier': rdflib.term.URIRef('http://hl7.org/fhir/Account.identifier'),
'implicitRules': rdflib.term.URIRef('http://hl7.org/fhir/Resource.implicitRules'),
'language': rdflib.term.URIRef('http://hl7.org/fhir/Resource.language'),
'meta': rdflib.term.URIRef('http://hl7.org/fhir/Resource.meta'),
'modifierExtension': rdflib.term.URIRef('http://hl7.org/fhir/DomainResource.modifierExtension'),
'name': rdflib.term.URIRef('http://hl7.org/fhir/Account.name'),
'nodeRole': rdflib.term.URIRef('http://hl7.org/fhir/nodeRole'),
'owner': rdflib.term.URIRef('http://hl7.org/fhir/Account.owner'),
'partOf': rdflib.term.URIRef('http://hl7.org/fhir/Account.partOf'),
'servicePeriod': rdflib.term.URIRef('http://hl7.org/fhir/Account.servicePeriod'),
'status': rdflib.term.URIRef('http://hl7.org/fhir/Account.status'),
'subject': rdflib.term.URIRef('http://hl7.org/fhir/Account.subject'),
'text': rdflib.term.URIRef('http://hl7.org/fhir/DomainResource.text'),
'type': rdflib.term.URIRef('http://hl7.org/fhir/Account.type')}, m.predicates())
def test3(self):
from fhirtordf.fhir.fhirmetavoc import FHIRMetaVocEntry
m = FHIRMetaVocEntry(self.fhir_ontology, "Narrative")
preds = m.predicates()
v = []
for name in sorted(preds.keys()):
pred = preds[name]
t = m.predicate_type(pred)
v.append((name, str(t), 'A' if m.is_atom(pred) else 'P' if m.is_primitive(t) else 'C'))
self.assertEqual([
('div', 'http://hl7.org/fhir/xhtml', 'A'),
('extension', 'http://hl7.org/fhir/Extension', 'C'),
('id', 'http://hl7.org/fhir/string', 'P'),
('index', 'http://www.w3.org/2001/XMLSchema#nonNegativeInteger', 'A'),
('status', 'http://hl7.org/fhir/code', 'P')], v)
def __init__(self,
vocabulary: Graph,
json_fname: Optional[str],
base_uri: str,
data: Optional[JsonObj] = None,
target: Optional[Graph] = None,
add_ontology_header: bool = True,
replace_narrative_text: bool = False,
is_root=True,
resource_uri: Optional[URIRef] = None):
"""
Construct an RDF representation
:param vocabulary: FHIR Metadata Vocabulary (fhir.ttl)
:param json_fname: URI or file name of resource to convert
:param base_uri: base of resource URI -- will be combined with the resource id to generate the actual URI
:param data: if present load this data rather than json_fname
:param target: target graph -- used for collections, bundles, etc.
:param add_ontology_header: Add the OWL ontology header to the output
:param replace_narrative_text: Replace long narrative text section with boilerplate
:param is_root: True means this is a root node, False a component
:param resource_uri: If present, this becomes the resource subject
"""
if json_fname:
self.root = load(json_fname)
elif data:
self.root = data
else:
assert False, "Either a json file name or actual data image must be supplied"
self._base_uri = base_uri + ('/' if base_uri[-1] not in '/#' else '')
if 'resourceType' not in self.root:
raise ValueError("{} is not a FHIR resource".format(json_fname))
if resource_uri:
self._resource_uri = resource_uri
else:
if 'id' not in self.root:
self.root.id = str(uuid4())
self._resource_uri = URIRef(self._base_uri +
self.root.resourceType + '/' +
self.root.id)
self._meta = FHIRMetaVocEntry(vocabulary, FHIR[self.root.resourceType])
self._g = PrettyGraph() if target is None else target
self._vocabulary = vocabulary
self._addl_namespaces = dict()
self._add_ontology_header = add_ontology_header
self._replace_narrative_text = replace_narrative_text
self.generate(is_root)
def test_fhir_dates(self):
from fhirtordf.fhir.fhirmetavoc import FHIRMetaVocEntry
m = FHIRMetaVocEntry(self.fhir_ontology, "Account")
FHIRMetaVocEntry.fhir_dates = False
self.assertEqual(XSD.dateTime,
m.primitive_datatype_nostring(FHIR.dateTime, "2009"))
self.assertEqual(
XSD.dateTime,
m.primitive_datatype_nostring(FHIR.dateTime, "2009-11"))
self.assertEqual(
XSD.dateTime,
m.primitive_datatype_nostring(FHIR.dateTime, "2009-11-30"))
self.assertEqual(
XSD.dateTime,
m.primitive_datatype_nostring(FHIR.dateTime,
"2009-11-30T09:00:00Z"))
self.assertEqual(
XSD.dateTime,
m.primitive_datatype_nostring(FHIR.dateTime, "2009-11-30+10"))
self.assertEqual(
XSD.dateTime,
m.primitive_datatype_nostring(FHIR.dateTime, "2009-11-30-9"))
FHIRMetaVocEntry.fhir_dates = True
self.assertEqual(XSD.gYear,
m.primitive_datatype_nostring(FHIR.dateTime, "2009"))
self.assertEqual(
XSD.gYearMonth,
m.primitive_datatype_nostring(FHIR.dateTime, "2009-11"))
self.assertEqual(
XSD.date, m.primitive_datatype_nostring(FHIR.dateTime,
"2009-11-30"))
self.assertEqual(
XSD.dateTime,
m.primitive_datatype_nostring(FHIR.dateTime,
"2009-11-30T09:00:00Z"))
self.assertEqual(
XSD.date,
m.primitive_datatype_nostring(FHIR.dateTime, "2009-11-30+10"))
self.assertEqual(
XSD.date,
m.primitive_datatype_nostring(FHIR.dateTime, "2009-11-30-9"))
def add_val(self,
subj: Node,
pred: URIRef,
json_obj: JsonObj,
json_key: str,
valuetype: Optional[URIRef] = None) -> Optional[BNode]:
"""
Add the RDF representation of val to the graph as a target of subj, pred. Note that FHIR lists are
represented as a list of BNODE objects with a fhir:index discrimanant
:param subj: graph subject
:param pred: predicate
:param json_obj: object containing json_key
:param json_key: name of the value in the JSON resource
:param valuetype: value type if NOT determinable by predicate
:return: value node if target is a BNode else None
"""
if json_key not in json_obj:
print("Expecting to find object named '{}' in JSON:".format(
json_key))
print(json_obj._as_json_dumps())
print("entry skipped")
return None
val = json_obj[json_key]
if isinstance(val, List):
list_idx = 0
for lv in val:
entry_bnode = BNode()
# TODO: this is getting messy. Refactor and clean this up
if pred == FHIR.Bundle.entry:
entry_subj = URIRef(lv.fullUrl)
self.add(entry_bnode, FHIR.index, Literal(list_idx))
self.add_val(entry_bnode, FHIR.Bundle.entry.fullUrl, lv,
'fullUrl')
self.add(entry_bnode, FHIR.Bundle.entry.resource,
entry_subj)
self.add(subj, pred, entry_bnode)
entry_mv = FHIRMetaVocEntry(self._vocabulary,
FHIR.BundleEntryComponent)
for k, p in entry_mv.predicates().items():
if k not in ['resource', 'fullUrl'] and k in lv:
print("---> adding {}".format(k))
self.add_val(subj, p, lv, k)
FHIRResource(self._vocabulary,
None,
self._base_uri,
lv.resource,
self._g,
False,
self._replace_narrative_text,
False,
resource_uri=entry_subj)
else:
self.add(entry_bnode, FHIR.index, Literal(list_idx))
if isinstance(lv, JsonObj):
self.add_value_node(entry_bnode, pred, lv, valuetype)
else:
vt = self._meta.predicate_type(pred)
atom_type = self._meta.primitive_datatype_nostring(
vt) if vt else None
self.add(entry_bnode, FHIR.value,
Literal(lv, datatype=atom_type))
self.add(subj, pred, entry_bnode)
list_idx += 1
else:
vt = self._meta.predicate_type(
pred) if not valuetype else valuetype
if self._meta.is_atom(pred):
if self._replace_narrative_text and pred == FHIR.Narrative.div and len(
val) > 120:
val = REPLACED_NARRATIVE_TEXT
self.add(subj, pred, Literal(val))
else:
v = BNode()
if self._meta.is_primitive(vt):
self.add(
v, FHIR.value,
Literal(
str(val),
datatype=self._meta.primitive_datatype_nostring(
vt, val)))
else:
self.add_value_node(v, pred, val, valuetype)
self.add(subj, pred, v)
if pred == FHIR.Reference.reference:
self.add_reference(subj, val)
elif pred == FHIR.RelatedArtifact.resource:
self.add_reference(v, val)
self.add_extension_val(v, json_obj, json_key)
return v
return None