def individual_to_fhir(obj):
"""Converts Individual to FHIR Patient.
:param obj: Individual json
:return: FHIR Patient json
"""
# first validate if phenopackets object is well-formed
schema_path = os.path.join(SCHEMA_PATH, 'individual_schema.json')
try:
validate_schema(schema_path, obj)
except jsonschema.exceptions.ValidationError:
raise Exception("The individual object is not valid.")
patient = p.Patient()
patient.id = obj['id']
patient.birthDate = fhirdate.FHIRDate(obj.get('dateOfBirth', None))
patient.gender = obj.get('sex', None)
patient.active = obj.get('active', None)
patient.deceasedBoolean = obj.get('deceased', None)
patient.extension = list()
# age
if 'age' in obj:
age_extension = age_to_fhir(
obj, PHENOPACKETS_ON_FHIR_MAPPING['individual']['age'], 'age')
patient.extension.append(age_extension)
# karyotypic_sex
if 'karyotypicSex' in obj:
karyotypic_sex_extension = extension.Extension()
karyotypic_sex_extension.url = PHENOPACKETS_ON_FHIR_MAPPING[
'individual']['karyotypicSex']['url']
karyotypic_sex_extension.valueCodeableConcept = codeableconcept.CodeableConcept(
)
karyotypic_sex_extension.valueCodeableConcept.coding = list()
coding = c.Coding()
coding.display = obj.get('karyotypicSex', None)
coding.code = obj.get('karyotypicSex', None)
coding.system = PHENOPACKETS_ON_FHIR_MAPPING['individual'][
'karyotypicSex']['system']
karyotypic_sex_extension.valueCodeableConcept.coding.append(coding)
patient.extension.append(karyotypic_sex_extension)
# taxonomy
if 'taxonomy' in obj:
taxonomy_extension = extension.Extension()
taxonomy_extension.url = PHENOPACKETS_ON_FHIR_MAPPING['individual'][
'taxonomy']
taxonomy_extension.valueCodeableConcept = codeableconcept.CodeableConcept(
)
taxonomy_extension.valueCodeableConcept.coding = list()
coding = c.Coding()
coding.display = obj.get('taxonomy', None).get('label', None)
coding.code = obj.get('taxonomy', None).get('id', None)
taxonomy_extension.valueCodeableConcept.coding.append(coding)
patient.extension.append(taxonomy_extension)
return patient.as_json()
def to_fhir(self):
route_coding = coding.Coding()
route_coding.system = self.system
route_coding.code = self.code
route_coding.display = self.display
return route_coding
def to_fhir(self) -> coding.Coding:
ingredient_coding = coding.Coding()
ingredient_coding.system = self.system
ingredient_coding.code = self.code
ingredient_coding.display = self.display
return ingredient_coding
def __init__(self, Organization=None):
"""
Uses fhirclient.models to create and post practitoner resource. Currently, using class variables.
:param smart: fhirclient.client.FHIRClient object.
:returns: practitioner id created by server
"""
if Organization is None:
self.Organization = generateorganization.GenerateOrganization(
).Organization
else:
self.Organization = Organization
Practitioner = pr.Practitioner()
PractitionerQualification = pr.PractitionerQualification()
CodeableConcept = cc.CodeableConcept()
Coding = c.Coding()
Coding.code = random.choice(['MD', 'DO'])
Coding.system = 'https://www.hl7.org/fhir/v2/0360/2.7/index.html'
CodeableConcept.coding = [Coding]
PractitionerQualification.code = CodeableConcept
Practitioner.qualification = [PractitionerQualification]
name = hn.HumanName()
self.family, self.given, Practitioner.gender = self._generate_person()
name.family = [self.family]
name.given = [self.given]
Practitioner.name = name
self._validate(Practitioner)
self.response = self.post_resource(Practitioner)
Practitioner.id = self._extract_id()
self.Practitioner = Practitioner
print(self)
def to_fhir(self) -> coding.Coding:
fhir_coding = coding.Coding()
fhir_coding.system = self.system
fhir_coding.code = self.code
fhir_coding.display = self.display
return fhir_coding
def _get_section_object(nested_obj, title):
"""Internal function to convert phenopacket m2m objects to Composition section.
:param nested_obj: m2m relationship object
:param title: field name that holds m2m relationship
:return: section content object
"""
section_content = comp.CompositionSection()
section_values = PHENOPACKETS_ON_FHIR_MAPPING['phenopacket'][title]
section_content.title = section_values['title']
section_content.code = codeableconcept.CodeableConcept()
section_content.code.coding = []
coding = c.Coding()
coding.system = section_values['code']['system']
coding.version = section_values['code']['version']
coding.code = section_values['code']['code']
coding.display = section_values['code']['display']
section_content.code.coding.append(coding)
section_content.entry = []
for item in nested_obj:
entry = fhirreference.FHIRReference()
if item.get('id'):
entry.reference = str(item['id'])
elif item.get('uri'):
entry.reference = item['uri']
else:
# generate uuid when no 'id' or 'uri' present
entry.reference = str(uuid.uuid1())
section_content.entry.append(entry)
return section_content
def mkCoding(**keywords):
'''
returns a Coding using keyword/values
'''
cod = c.Coding()
for key in keywords:
setattr(cod, key, keywords[key])
return cod
def to_fhir(self) -> extension.Extension:
fhir_extension = extension.Extension()
fhir_extension.url = self.extension_url
fhir_coding = coding.Coding()
fhir_coding.system = self.system
fhir_coding.code = self.code
fhir_coding.display = self.display
fhir_extension.valueCoding = fhir_coding
return fhir_extension
def to_fhir(self) -> extension.Extension:
ingredient_extension = extension.Extension()
ingredient_extension.url = self.url
extension_coding = coding.Coding()
extension_coding.system = self.coding_system
extension_coding.code = self.coding_code
extension_coding.display = self.coding_display
ingredient_extension.valueCoding = extension_coding
return ingredient_extension
def map_cc(concept):
# create CodeableConcept based on slot data
cc = CC.CodeableConcept()
cc.coding = []
cc.text = concept.text
try:
cc_coding = Coding.Coding()
for translation in concept.coding:
cc_coding.code = translation.code
cc_coding.display = translation.display
cc_coding.system = translation.system
cc.coding.append(cc_coding)
except TypeError: # coding missing
pass
return (cc)
def getcoding(code, system, display, extension): # fhircoding
coding = C.Coding()
# attempt to fix this using the standard Argo extension made more difficult. easier to support both especially when contained vs.
try:
for ext in extension:
if ext.url == 'http://hl7.org/fhir/StructureDefinition/valueset-ordinalValue':
ext.url = 'http://hl7.org/fhir/StructureDefinition/valueset-ordinalValue'
coding.extension = extension
except TypeError: # extension missing
pass
try:
coding.code = code
coding.display = display
coding.system = system
except TypeError: # coding missing
pass
return(coding)
def build_keyword(study_keywords):
"""
Build the keywords up
:param keywords:
:return:
"""
keywords = []
for term in study_keywords:
cc = codeableconcept.CodeableConcept()
cc.text = term
cc.coding = [
coding.Coding(
dict(code=quote(term),
system="https://example.org",
display=term))
]
keywords.append(cc)
return keywords
def build_focus(mesh_terms):
"""
Build the ResearchStudy.focus
:param conditions:
:param interventions:
:return:
"""
# assuming mesh term here
focus = []
for study_term_type, terms in mesh_terms.items():
print("{}: {}".format(study_term_type, terms))
for term in terms:
cc = codeableconcept.CodeableConcept()
cc.text = term
cc.coding = [
coding.Coding(
dict(code=term, system="https://mesh.org", display=""))
]
focus.append(cc)
return focus
def write(server_url, system, code, patient, value):
observation = o.Observation()
observation.status = "final"
observation.subject = fr.FHIRReference()
observation.subject.reference = ("Patient/%s" % patient)
observation.code = cc.CodeableConcept()
tmp = c.Coding()
tmp.system = system
tmp.code = code
observation.code.coding = [tmp]
observation.valueString = str(value)
observation.effectiveDateTime = fd.FHIRDate("2017-11-28T00:00:00+00:00")
#write json obj
json_obj = observation.as_json()
json_obj["resourceType"] = "Observation"
print(json.dumps(json_obj))
requests.post(server_url + "Observation", json=json_obj)
def __init__(self,
Patient=None,
Provider=None,
Location=None,
Condition=None,
Period=None,
status='in-progress',
fhir_class='outpatient'):
"""Uses fhirclient.models to create encounter resource"""
if Patient is not None and Condition is not None:
if Patient.id != Condition.Patient.id:
raise ValueError(
'Patient.id must equal Conditition.Patient.id.')
self.Patient = Patient
self.Condition = Condition
elif Condition is None and Patient is None:
self.Condition = generatecondition.GenerateCondition().Condition
self.Patient = self.Condition.Patient
elif Condition is not None and Patient is None:
self.Condition = Condition
self.Patient = self.Condition.Patient
elif Condition is None and Patient is not None:
self.Patient = Patient
self.Condition = generatecondition.GenerateCondition(
Patient=self.Patient).Condition
else:
raise ValueError('Error with Patient and Condition values')
if Location == None:
self.Location = generatelocation.GenerateLocation().Location
else:
self.Location = Location
if Period == None:
self.Period = self._create_FHIRPeriod()
else:
self.Period = Period
if Provider == None:
self.Practitioner = generatepractitioner.GeneratePractitioner(
).Practitioner
else:
self.Practitioner = Provider
self.status = status
self.fhir_class = fhir_class
Encounter = enc.Encounter()
Coding = c.Coding()
Coding.code = self.fhir_class
Encounter.class_fhir = Coding
Encounter.status = self.status
EncounterLocation = enc.EncounterLocation()
EncounterLocation.location = self._create_FHIRReference(self.Location)
Encounter.location = [EncounterLocation]
Encounter.subject = self._create_FHIRReference(self.Patient)
EncounterDiagnosis = enc.EncounterDiagnosis()
EncounterDiagnosis.condition = self._create_FHIRReference(
self.Condition)
Encounter.diagnosis = [EncounterDiagnosis]
EncounterParticipant = enc.EncounterParticipant()
EncounterParticipant.individual = self._create_FHIRReference(
self.Practitioner)
Encounter.participant = [EncounterParticipant]
Encounter.period = self.Period
# self._validate(Encounter)
self.response = Encounter.create(server=self.connect2server().server)
Encounter.id = self._extract_id()
self.Encounter = Encounter
self.Encounter.Patient = self.Patient
self.Encounter.Condition = self.Condition
self.Encounter.Location = self.Location
self.Encounter.Period = self.Period
self.Encounter.Practitioner = self.Practitioner
def create_fhir_object(self):
"""
Generate a fhirclient.Patient class object and store in the protected attribute _fhir
:return:
None
"""
# Patient object must be persistent to generate FHIR attributes
ins = inspect(self)
if ins.persistent:
# Initialize Patient resource
fhir_pt = fhir_patient.Patient()
# Set resource logical identifier
fhir_pt.id = self.get_url()
# Build and assign Meta resource for Patient object
fhir_meta = meta.Meta()
fhir_meta.lastUpdated = fhir_gen_datetime(value=self.updated_at, error_out=False, to_date=False)
fhir_meta.versionId = str(self.version_number)
fhir_meta.profile = ['http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient']
fhir_pt.meta = fhir_meta
# Patient name represented as HumanName resource
fhir_pt.name = []
fhir_pt.name.append(fhir_gen_humanname(use='usual', first_name=self.first_name, last_name=self.last_name,
middle_name=self.middle_name, suffix=self.suffix,
prefix=self.prefix))
# Display MRN as identifier codeable concept = Patient.identifier.codeableconcept.coding
# Initialize Identifier resource
id_mrn = identifier.Identifier()
id_mrn.use = 'usual'
id_mrn.system = 'http://unkani.com'
id_mrn.value = str(self.uuid)
# Initialize CodeableConcept resource
mrn_cc = codeableconcept.CodeableConcept()
mrn_cc.text = 'Medical Record Number'
# Initialize Coding resource
mrn_coding = coding.Coding()
mrn_coding.system = 'http://hl7.org/fhir/v2/0203'
mrn_coding.code = 'MR'
mrn_coding.display = 'Medical Record Number'
# Assign Coding resource to CodeableConcept
mrn_cc.coding = [mrn_coding]
# Assign CodeableConcept to Identifier
id_mrn.type = mrn_cc
# Assign CodeableConcept to Patient
fhir_pt.identifier = [id_mrn]
# Display SSN as identifier codeable concept = Patient.identifier.codeableconcept.coding
if self.ssn:
# Initialize Identifier resource
id_ssn = identifier.Identifier()
id_ssn.use = 'usual'
id_ssn.system = 'http://hl7.org/fhir/sid/us-ssn'
id_ssn.value = self.ssn
# Initialize CodeableConcept resource
ssn_cc = codeableconcept.CodeableConcept()
ssn_cc.text = 'Social Security Number'
# Initialize Coding resource
ssn_coding = coding.Coding()
ssn_coding.system = 'http://hl7.org/fhir/v2/0203'
ssn_coding.code = 'SS'
ssn_coding.display = 'Social Security Number'
# Assign Coding resource to CodeableConcept
ssn_cc.coding = [ssn_coding]
# Assign CodeableConcept to Identifier
id_ssn.type = ssn_cc
# Assign CodeableConcept to Patient
fhir_pt.identifier.append(id_ssn)
if self.marital_status:
marital_status_cc = codeableconcept.CodeableConcept()
marital_status_url = 'http://hl7.org/fhir/ValueSet/marital-status'
marital_status_concept = ValueSet.get_valueset_concept(marital_status_url, self.marital_status)
if marital_status_concept:
marital_status_cc.text = getattr(marital_status_concept, 'display')
marital_status_coding = coding.Coding()
marital_status_coding.code = self.marital_status
marital_status_coding.system = marital_status_url
marital_status_coding.display = marital_status_cc.text
marital_status_cc.coding = [marital_status_coding]
fhir_pt.maritalStatus = marital_status_cc
if self.race:
ext_race = extension.Extension()
ext_race.url = 'http://hl7.org/fhir/StructureDefinition/us-core-race'
race_url = 'http://hl7.org/fhir/us/core/ValueSet/omb-race-category'
cc_race = codeableconcept.CodeableConcept()
race_concept = ValueSet.get_valueset_concept(race_url, self.race)
if race_concept:
cc_race.text = getattr(race_concept, 'display')
coding_race = coding.Coding()
coding_race.system = race_url
coding_race.code = self.race
coding_race.display = cc_race.text
cc_race.coding = [coding_race]
ext_race.valueCodeableConcept = cc_race
try:
fhir_pt.extension.append(ext_race)
except AttributeError:
fhir_pt.extension = [ext_race]
if self.ethnicity:
ext_ethnicity = extension.Extension()
ext_ethnicity.url = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity'
cc_ethnicity = codeableconcept.CodeableConcept()
cc_ethnicity.text = ethnicity_dict.get(self.ethnicity)[0].capitalize()
coding_ethnicity = coding.Coding()
coding_ethnicity.system = 'http://hl7.org/fhir/us/core/ValueSet/omb-ethnicity-category'
coding_ethnicity.code = self.race
coding_ethnicity.display = cc_ethnicity.text
cc_ethnicity.coding = [coding_ethnicity]
ext_ethnicity.valueCodeableConcept = cc_ethnicity
try:
fhir_pt.extension.append(ext_ethnicity)
except AttributeError:
fhir_pt.extension = [ext_ethnicity]
if self.sex:
sex_dict = {"administrativeGender": {"M": "male", "F": "female", "u": "unknown", "o": "other"},
"usCoreBirthSex": {"M": "M", "F": "F", "U": "UNK", "O": "UNK"}}
fhir_pt.gender = sex_dict['administrativeGender'][str(self.sex).upper()]
ext_birth_sex = extension.Extension()
ext_birth_sex.url = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex'
ext_birth_sex.valueCode = sex_dict['usCoreBirthSex'][str(self.sex).upper()]
try:
fhir_pt.extension.append(ext_birth_sex)
except AttributeError:
fhir_pt.extension = [ext_birth_sex]
if self.dob:
fhir_pt.birthDate = fhir_gen_datetime(value=self.dob, to_date=True)
fhir_pt.active = self.active
fhir_pt.deceasedBoolean = self.deceased
if self.deceased_date:
fhir_pt.deceasedDateTime = fhir_gen_datetime(value=self.deceased_date, to_date=False)
if self.preferred_language:
fhir_comm = fhir_patient.PatientCommunication()
fhir_comm.preferred = True
fhir_lang_cc = codeableconcept.CodeableConcept()
fhir_lang_coding = coding.Coding()
fhir_lang_coding.code = self.preferred_language
fhir_lang_url = 'http://hl7.org/fhir/ValueSet/languages'
fhir_lang_coding.system = fhir_lang_url
fhir_lang_concept = ValueSet.get_valueset_concept(fhir_lang_url, self.preferred_language)
if fhir_lang_concept:
fhir_lang_coding.display = fhir_lang_concept.display
fhir_lang_cc.text = fhir_lang_coding.display
fhir_lang_cc.coding = [fhir_lang_coding]
fhir_comm.language = fhir_lang_cc
fhir_pt.communication = [fhir_comm]
contact_point_list = []
phone_list = self.phone_numbers.all()
if phone_list:
for ph in phone_list:
contact_point_list.append(ph.fhir)
email_list = self.email_addresses.all()
if email_list:
for em in email_list:
contact_point_list.append(em.fhir)
if contact_point_list:
fhir_pt.telecom = contact_point_list
address_list = self.addresses.all()
if address_list:
fhir_pt.address = []
for addr in address_list:
fhir_pt.address.append(addr.fhir)
xhtml = render_template('fhir/patient.html', fhir_patient=fhir_pt, patient=self)
fhir_pt.text = narrative.Narrative()
fhir_pt.text.status = 'generated'
fhir_pt.text.div = xhtml
self._fhir = fhir_pt
def biosample_to_fhir(obj):
"""Converts Biosample to FHIR Specimen.
:param obj: Biosample json
:return: FHIR Specimen json
"""
schema_path = os.path.join(SCHEMA_PATH, 'biosample_schema.json')
try:
validate_schema(schema_path, obj)
except jsonschema.exceptions.ValidationError:
raise Exception("The biosample object is not valid.")
specimen = s.Specimen()
specimen.identifier = []
# id
identifier = fhir_indentifier.Identifier()
identifier.value = obj['id']
specimen.identifier.append(identifier)
# individual - subject property in FHIR is mandatory for a specimen
specimen.subject = fhirreference.FHIRReference()
specimen.subject.reference = obj.get('individual', 'unknown')
# sampled_tissue
specimen.type = codeableconcept.CodeableConcept()
specimen.type.coding = []
coding = c.Coding()
coding.code = obj['sampledTissue']['id']
coding.display = obj['sampledTissue']['label']
specimen.type.coding.append(coding)
# description
if 'description' in obj:
specimen.note = []
annotation = a.Annotation()
annotation.text = obj.get('description', None)
specimen.note.append(annotation)
# procedure
specimen.collection = s.SpecimenCollection()
specimen.collection.method = fhir_codeable_concept(
obj['procedure']['code'])
if 'bodySite' in obj['procedure']:
specimen.collection.bodySite = fhir_codeable_concept(
obj['procedure']['bodySite'])
# Note on taxonomy from phenopackets specs:
# Individuals already contain a taxonomy attribute so this attribute is not needed.
# extensions
specimen.extension = []
# individual_age_at_collection
if 'individualAgeAtCollection' in obj:
ind_age_at_collection_extension = age_to_fhir(
obj, PHENOPACKETS_ON_FHIR_MAPPING['biosample']
['individualAgeAtCollection'], 'individualAgeAtCollection')
specimen.extension.append(ind_age_at_collection_extension)
concept_extensions = codeable_concepts_fields([
'histologicalDiagnosis', 'tumorProgression', 'tumorGrade',
'diagnosticMarkers'
], 'biosample', obj)
for concept in concept_extensions:
specimen.extension.append(concept)
if 'isControlSample' in obj:
control_extension = extension.Extension()
control_extension.url = PHENOPACKETS_ON_FHIR_MAPPING['biosample'][
'isControlSample']
control_extension.valueBoolean = obj['isControlSample']
specimen.extension.append(control_extension)
# TODO 2m extensions - references
return specimen.as_json()
