fhir-sheets 1.1.0__py3-none-any.whl

fhir_sheets/cli/fhirsheets.py

@@ -0,0 +1,64 @@
+from ..core import read_input
+from ..core import conversion
+
+import argparse
+import orjson
+import json
+from pathlib import Path
+
+def find_sets(d, path=""):
+    if isinstance(d, dict):
+        for key, value in d.items():
+            new_path = f"{path}.{key}" if path else str(key)
+            find_sets(value, new_path)
+    elif isinstance(d, list):  # Handle lists of dictionaries
+        for idx, item in enumerate(d):
+            find_sets(item, f"{path}[{idx}]")
+    elif isinstance(d, set):
+        print(f"Set found at path: {path}")
+        
+def main(input_file, output_folder):
+    # Step 1: Read the input file using read_input module
+    
+    # Check if the output folder exists, and create it if not
+    
+    output_folder_path = Path(output_folder)
+    if not output_folder_path.is_absolute():
+        output_folder_path = Path().cwd() / Path(output_folder)
+    if not output_folder_path.exists():
+        output_folder_path.mkdir(parents=True, exist_ok=True)  # Create the folder if it doesn't exist
+    data = read_input.read_xlsx_and_process(input_file)
+    resource_definition_entities = data['resource_definition_entities']
+    
+    #For each index of patients
+    for i in range(0,data['num_entries']):
+        # Construct the file path for each JSON file
+        file_path = output_folder_path / f"{i}.json"
+        #Create a bundle
+        fhir_bundle = conversion.create_transaction_bundle(data['resource_definition_entities'],
+                                                        data['resource_link_entities'], data['patient_data_entities'], i)
+        # Step 3: Write the processed data to the output file
+        find_sets(fhir_bundle)
+        json_string = orjson.dumps(fhir_bundle)
+        with open(file_path, 'wb') as json_file:
+            json_file.write(json_string)
+        with open(file_path, 'r') as json_file:
+            json_string = json.load(json_file)
+        with open(file_path, 'w') as json_file:
+            json.dump(json_string, json_file, indent = 4)
+
+if __name__ == "__main__":
+    # Create the argparse CLI
+    parser = argparse.ArgumentParser(description="Process input, convert data, and write output.")
+    
+    # Define the input file argument
+    parser.add_argument('--input_file', type=str, help="Path to the input xlsx ", default="src/resources/Synthetic_Input_Baseline.xlsx")
+    
+    # Define the output file argument
+    parser.add_argument('--output_folder', type=str, help="Path to save the output files", default="output/")
+    
+    # Parse the arguments
+    args = parser.parse_args()
+
+    # Call the main function with the provided arguments
+    main(args.input_file, args.output_folder)

fhir_sheets/core/conversion.py

@@ -0,0 +1,308 @@
+import uuid
+from jsonpath_ng.jsonpath import Fields, Slice, Where
+from jsonpath_ng.ext import parse as parse_ext
+from . import fhir_formatting
+from . import special_values
+
+#Main top level function
+#Creates a full transaction bundle for a patient at index
+def create_transaction_bundle(resource_definition_entities, resource_link_entities, patient_data, index = 0):
+    root_bundle = initialize_bundle()
+    created_resources = {}
+    for resource_definition in resource_definition_entities:
+        entity_name = resource_definition['Entity Name']
+        #Create and collect fhir resources
+        fhir_resource = create_fhir_resource(resource_definition, patient_data, index)
+        created_resources[entity_name] = fhir_resource
+    #Link resources after creation
+    add_default_resource_links(created_resources, resource_link_entities)
+    create_resource_links(created_resources, resource_link_entities)
+    #Construct into fhir bundle
+    for fhir_resource in created_resources.values():
+        add_resource_to_transaction_bundle(root_bundle, fhir_resource)
+    return root_bundle
+
+#Initialize root bundle definition
+def initialize_bundle():
+    root_bundle = {}
+    root_bundle['resourceType'] = 'Bundle'
+    root_bundle['id'] = str(uuid.uuid4())
+    root_bundle['type'] = 'transaction'
+    root_bundle['entry'] = []
+    return root_bundle
+
+# Creates a fhir-json structure from a resource definition entity and the patient_data_sheet
+def create_fhir_resource(resource_definition, patient_data, index = 0):
+    resource_dict = initialize_resource(resource_definition)
+    #Get field entries for this entitiy
+    try:
+        all_field_entries = patient_data[resource_definition['Entity Name']]
+    except KeyError:
+        print(f"WARNING: Patient index {index} - Create Fhir Resource Error - {resource_definition['Entity Name']} - No columns for entity '{resource_definition['Entity Name']}' found for resource in 'PatientData' sheet")
+        return resource_dict
+    #For each field within the entity
+    for field_entry in all_field_entries.values():
+        #Create a jsonpath from each provided json path and value for this resource
+        if field_entry['values'] and len(field_entry['values']) > index:
+            create_structure_from_jsonpath(resource_dict, field_entry['jsonpath'], resource_definition, field_entry, field_entry['valueType'], field_entry['values'][index])
+    return resource_dict
+        
+#Initialize a resource from a resource definition. Adding basic 
+def initialize_resource(resource_definition):
+    initial_resource = {}
+    initial_resource['resourceType'] = resource_definition['ResourceType'].strip()
+    resource_definition['id'] = str(uuid.uuid4())
+    initial_resource['id'] = resource_definition['id'].strip()
+    if resource_definition['Profile(s)']:
+        initial_resource['meta'] = {
+            'profile': resource_definition['Profile(s)']
+        }
+    return initial_resource
+
+#Create a resource_link for default references in the cases where only 1 resourceType of the source and destination exist
+def add_default_resource_links(created_resources, resource_link_entities):
+    default_references = [
+        ('allergyintolerance', 'patient', 'patient'),
+        ('allergyintolerance', 'practitioner', 'asserter'),
+        ('careplan', 'goal', 'goal'),
+        ('careplan', 'patient', 'subject'),
+        ('careplan', 'practitioner', 'performer'),
+        ('diagnosticreport', 'careteam', 'performer'),
+        ('diagnosticreport', 'imagingStudy', 'imagingStudy'),
+        ('diagnosticreport', 'observation', 'result'),
+        ('diagnosticreport', 'organization', 'performer'),
+        ('diagnosticreport', 'practitioner', 'performer'),
+        ('diagnosticreport', 'practitionerrole', 'performer'),
+        ('diagnosticreport', 'specimen', 'specimen'),
+        ('encounter', 'location', 'location'),
+        ('encounter', 'organization', 'serviceProvider'),
+        ('encounter', 'patient', 'subject'),
+        ('encounter', 'practitioner', 'participant'),
+        ('goal', 'condition', 'addresses'),
+        ('goal', 'patient', 'subject'),
+        ('immunization', 'patient', 'patient'),
+        ('immunization', 'practitioner', 'performer'),
+        ('immunization', 'organization', 'manufacturer'),
+        ('medicationrequest', 'medication', 'medicationReference'),
+        ('medicationrequest', 'patient', 'subject'),
+        ('medicationrequest', 'practitioner', 'requester'),
+        ('observation', 'device', 'device'),
+        ('observation', 'patient', 'subject'),
+        ('observation', 'practitioner', 'performer'),
+        ('observation', 'specimen', 'specimen'),
+        ('procedure', 'device', 'usedReference'),
+        ('procedure', 'location', 'location'),
+        ('procedure', 'patient', 'subject'),
+        ('procedure', 'practitioner', 'performer'),
+    ]
+    
+    resource_counts = {}
+    for resourceName, resource in created_resources.items():
+        resourceType = resource['resourceType'].lower().strip()
+        if resourceType not in resource_counts:
+            resource_counts[resourceType]= {'count': 1, 'singletonEntityName': resourceName, 'singleResource': resource}
+        else:
+            resource_counts[resourceType]['count'] += 1
+            resource_counts[resourceType]['singletonResource'] = resource
+            resource_counts[resourceType]['singletonEntityName'] = resourceName
+            
+    for default_reference in default_references:
+        sourceType = default_reference[0]
+        destinationType = default_reference[1]
+        fieldName = default_reference[2]
+        if sourceType in resource_counts and destinationType in resource_counts and \
+        resource_counts[sourceType]['count'] == 1 and resource_counts[destinationType]['count'] == 1:
+            originResourceEntityName = resource_counts[sourceType]['singletonEntityName']
+            destinationResourceEntityName = resource_counts[destinationType]['singletonEntityName']
+            resource_link_entities.append(
+                {
+                    "OriginResource": originResourceEntityName,
+                    "DestinationResource": destinationResourceEntityName,
+                    "ReferencePath": fieldName
+                }
+            )
+    return
+        
+            
+#Create resource references/links with created entities
+def create_resource_links(created_resources, resource_link_entites):
+    reference_json_block = {
+        "reference" : "$value"
+    }
+
+    arrayType_references = [
+        ('diagnosticreport', 'specimen', 'specimen'),
+        ('diagnosticreport', 'practitioner', 'performer'),
+        ('diagnosticreport', 'practitionerrole', 'performer'),
+        ('diagnosticreport', 'organization', 'performer'),
+        ('diagnosticreport', 'careteam', 'performer'),
+        ('diagnosticreport', 'observation', 'result'),
+        ('diagnosticreport', 'imagingStudy', 'imagingStudy'),
+    ]
+    #TODO: Build resource links
+    print("Building resource links")
+    for resource_link_entity in resource_link_entites:
+        try:
+            origin_resource = created_resources[resource_link_entity['OriginResource']]
+        except KeyError:
+            print(f"WARNING: In ResourceLinks tab, found a Origin Resource of : {resource_link_entity['OriginResource']}  but no such entity found in PatientData")
+            continue
+        try:
+            destination_resource = created_resources[resource_link_entity['DestinationResource']]
+        except KeyError:
+            print(f"WARNING: In ResourceLinks tab, found a Desitnation Resource  of : {resource_link_entity['DestinationResource']}  but no such entity found in PatientData")
+            continue
+        destination_resource_type = created_resources[resource_link_entity['DestinationResource']]['resourceType']
+        destination_resource_id = created_resources[resource_link_entity['DestinationResource']]['id']
+        link_tuple = (created_resources[resource_link_entity['OriginResource']]['resourceType'].strip().lower(),
+                      created_resources[resource_link_entity['DestinationResource']]['resourceType'].strip().lower(),
+                      resource_link_entity['ReferencePath'].strip().lower())
+        if link_tuple in arrayType_references:
+            if resource_link_entity['ReferencePath'].strip().lower() not in origin_resource:
+                origin_resource[resource_link_entity['ReferencePath'].strip().lower()] = []
+            new_reference = reference_json_block.copy()
+            new_reference['reference'] = destination_resource_type + "/" + destination_resource_id
+            origin_resource[resource_link_entity['ReferencePath'].strip().lower()].append(new_reference)
+        else:
+            origin_resource[resource_link_entity['ReferencePath'].strip().lower()] = reference_json_block.copy()
+            origin_resource[resource_link_entity['ReferencePath'].strip().lower()]["reference"] = destination_resource_type + "/" + destination_resource_id
+    return
+    
+def add_resource_to_transaction_bundle(root_bundle, fhir_resource):
+    entry = {}
+    entry['fullUrl'] = "urn:uuid:"+fhir_resource['id']
+    entry['resource'] = fhir_resource
+    entry['request'] = {
+      "method": "PUT",
+      "url": fhir_resource['resourceType'] + "/" + fhir_resource['id']
+    }
+    root_bundle['entry'].append(entry)
+    return root_bundle
+
+#Drill down and create a structure from a json path with a simple recurisve process
+# Supports 2 major features:
+# 1) dot notation such as $.codeableconcept.coding[0].value = 1234
+# 2) simple qualifiers such as $.name[use=official].family = Dickerson
+# rootStruct: top level structure to drill into
+# json_path: dotnotation path to follow
+# resource_definition: resource description model from import
+# entity_definition: specific field entry information for this function
+# value: Actual value to assign
+def create_structure_from_jsonpath(root_struct, json_path, resource_definition, entity_definition, dataType, value):
+    #Get all dot notation components as seperate 
+    if dataType is not None and dataType.strip().lower() == 'string':
+        value = str(value)
+    
+    if value == None:
+        print(f"WARNING: Full jsonpath: {json_path} - Expected to find a value but found None instead")
+        return root_struct
+    #Start of top-level function which calls the enclosed recursive function
+    parts = json_path.split('.')
+    return build_structure(root_struct, json_path, resource_definition, entity_definition, parts, value, [])
+
+# main recursive function to drill into the json structure, assign paths, and create structure where needed
+def build_structure(current_struct, json_path, resource_definition, entity_definition, parts, value, previous_parts):
+    if len(parts) == 0:
+        return current_struct
+    #Grab current part
+    part = parts[0]
+    #SPECIAL HANDLING CLAUSE
+    matching_handler = next((handler for handler in special_values.custom_handlers if (json_path.startswith(handler) or json_path == handler)), None)
+    if matching_handler is not None:
+        return special_values.custom_handlers[matching_handler].assign_value(json_path, resource_definition, entity_definition, current_struct, parts[-1], value)
+    #Ignore dollar sign ($) and drill farther down
+    if part == '$' or part == resource_definition['ResourceType'].strip():
+        #Ignore the dollar sign and the resourcetype
+        return build_structure_recurse(current_struct, json_path, resource_definition, entity_definition, parts, value, previous_parts, part)
+    
+    # If parts length is one then this is the final key to access and pair
+    if len(parts) == 1:
+        #Check for numeic qualifier '[0]' and '[1]'
+        if '[' in part and ']' in part:
+        #Seperate the key from the qualifier
+            key_part = part[:part.index('[')]
+            qualifier = part[part.index('[')+1:part.index(']')]
+            qualifier_condition = qualifier.split('=')
+            
+            #If there is no key part, aka '[0]', '[1]' etc, then it's a simple accessor
+            if key_part is None or key_part == '':
+                if not qualifier.isdigit():
+                    raise TypeError(f"ERROR: Full jsonpath: {json_path} - current path - {'.'.join(previous_parts + parts[:1])} - qualifier - {qualifier} - standalone qualifier expected to be a single index numeric ([0], [1], etc)")
+                if current_struct == {}:
+                    current_struct = []
+                if not isinstance(current_struct, list):
+                    raise TypeError(f"ERROR: Full jsonpath: {json_path} - current path - {'.'.join(previous_parts + parts[:1])} - Expected a list, but got {type(current_struct).__name__} instead.")
+                part = int(qualifier)
+                if part + 1 > len(current_struct):
+                    current_struct.extend({} for x in range (part + 1 - len(current_struct)))
+        #Actual assigning to the path
+        fhir_formatting.assign_value(current_struct, part, value, entity_definition['valueType'])
+        return current_struct
+    
+    # If there is a simple qualifier with '['and ']'
+    elif '[' in part and ']' in part:
+        #Seperate the key from the qualifier
+        key_part = part[:part.index('[')]
+        qualifier = part[part.index('[')+1:part.index(']')]
+        qualifier_condition = qualifier.split('=')
+        
+        #If there is no key part, aka '[0]', '[1]' etc, then it's a simple accessor
+        if key_part is None or key_part == '':
+            if not qualifier.isdigit():
+                raise TypeError(f"ERROR: Full jsonpath: {json_path} - current path - {'.'.join(previous_parts + parts[:1])} - qualifier - {qualifier} - standalone qualifier expected to be a single index numeric ([0], [1], etc)")
+            if current_struct == {}:
+                current_struct = []
+            if not isinstance(current_struct, list):
+                raise TypeError(f"ERROR: Full jsonpath: {json_path} - current path - {'.'.join(previous_parts + parts[:1])} - Expected a list, but got {type(current_struct).__name__} instead.")
+            qualifier_as_number = int(qualifier)
+            if qualifier_as_number + 1 > len(current_struct):
+                current_struct.extend({} for x in range (qualifier_as_number + 1 - len(current_struct)))
+            inner_struct = current_struct[qualifier_as_number]
+            inner_struct = build_structure_recurse(inner_struct, json_path, resource_definition, entity_definition, parts, value, previous_parts, part)
+            current_struct[qualifier_as_number] = inner_struct
+            return current_struct
+        # Create the key part in the structure
+        if (not key_part in current_struct) or (isinstance(current_struct[key_part], dict)):
+            current_struct[key_part] = []
+        #If there is a key_part and the If the qualifier condition is defined
+        if len(qualifier_condition) == 2:
+            #special handling for code
+            if key_part != "coding" and (qualifier_condition[0] in ('code', 'system')):
+                #Move into the coding section if a qualifier asks for 'code' or 'system'
+                if 'coding' not in current_struct:
+                    current_struct['coding'] = []
+                    current_struct = current_struct['coding']
+            qualifier_key, qualifier_value = qualifier_condition
+            # Retrieve an inner structure if it exists allready that matches the criteria
+            inner_struct = next((innerElement for innerElement in current_struct[key_part] if isinstance(innerElement, dict) and innerElement.get(qualifier_key) == qualifier_value), None)
+            #If no inner structure exists, create one instead
+            if inner_struct is None:
+                inner_struct = {qualifier_key: qualifier_value}
+                current_struct[key_part].append(inner_struct)
+            #Recurse into that innerstructure where the qualifier matched to continue the part traversal
+            inner_struct = build_structure_recurse(inner_struct, json_path, resource_definition, entity_definition, parts, value, previous_parts, part)
+            return current_struct
+        #If there's no qualifier condition, but an index aka '[0]', '[1]' etc, then it's a simple accessor
+        elif qualifier.isdigit():
+            if not isinstance(current_struct[key_part], list):
+                raise TypeError(f"ERROR: Full jsonpath: {json_path} - current path - {'.'.join(previous_parts + parts[0])} - Expected a list, but got {type(current_struct).__name__} instead.")
+            qualifier_as_number = int(qualifier)
+            if qualifier_as_number > len(current_struct):
+                current_struct[key_part].extend({} for x in range (qualifier_as_number - len(current_struct)))
+            inner_struct = current_struct[key_part][qualifier_as_number]
+            inner_struct = build_structure_recurse(inner_struct, json_path, resource_definition, entity_definition, parts, value, previous_parts, part)
+            current_struct[key_part][qualifier_as_number] = inner_struct
+            return current_struct
+    #None qualifier accessor
+    else:
+        if(part not in current_struct):
+            current_struct[part] = {}
+        inner_struct = build_structure_recurse(current_struct[part], json_path, resource_definition, entity_definition, parts, value, previous_parts, part)
+        current_struct[part] = inner_struct
+        return current_struct
+    
+#Helper function to quickly recurse and return the next level of structure. Used by main recursive function
+def build_structure_recurse(current_struct, json_path, resource_definition, entity_definition, parts, value, previous_parts, part):
+    previous_parts.append(part)
+    return_struct = build_structure(current_struct, json_path, resource_definition, entity_definition, parts[1:], value, previous_parts)
+    return return_struct

fhir_sheets/core/fhir_formatting.py

@@ -0,0 +1,279 @@
+import re
+from datetime import datetime, time, timezone
+
+#Dictionary of regexes
+type_regexes = {
+    'code': '[^\s]+( [^\s]+)*',
+    'decimal': '-?(0|[1-9][0-9]{0,17})(\.[0-9]{1,17})?([eE][+-]?[0-9]{1,9}})?',
+    'id': '[A-Za-z0-9\-\.]{1,64}',
+    'integer': '[0]|[-+]?[1-9][0-9]*',
+    'oid': 'urn:oid:[0-2](\.(0|[1-9][0-9]*))+',
+    'positiveInt': '[1-9][0-9]*',
+    'unsignedInt':'[0]|([1-9][0-9]*)',
+    'uuid':'urn:uuid:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'
+}
+# Assign final_struct[key] to value; with formatting given the valueType
+def assign_value(final_struct, key, value, valueType):
+    # Removing white space
+    if isinstance(value, str):
+        value = value.strip()
+    # Checking for null or empty string values. If so; we do not construct the value
+    if not value:
+        return final_struct
+    # If the valueType is not provide, do not construct the value.
+    if valueType is None:
+        return final_struct
+    # Swtich case for valueType to construct a value
+    try:
+        if valueType.lower() == 'address':
+            address_value = parse_flexible_address(value)
+            if address_value:
+                final_struct[key] = address_value
+        elif valueType.lower() == 'base64binary':
+            final_struct[key] = value
+        elif valueType.lower() == 'boolean':
+            final_struct[key] = bool(value)
+        elif valueType.lower() == 'codeableconcept':
+            final_struct[key] = caret_delimited_string_to_codeableconcept(value)
+        elif valueType.lower() == 'code':
+            match = re.search(type_regexes['code'], value)
+            final_struct[key] = match.group(0) if match else ''
+        elif valueType.lower() == 'coding':
+            final_struct[key] = caret_delimited_string_to_coding(value)
+        elif valueType.lower() == 'date':
+            if isinstance(value, datetime):
+                final_struct[key] = value.date()
+            elif isinstance(value, str):
+                final_struct[key] = parse_iso8601_date(value).replace(tzinfo=timezone.utc)
+        elif valueType.lower() == 'datetime':
+            if isinstance(value, datetime):
+                final_struct[key] = value.replace(tzinfo=timezone.utc)
+            else:
+                final_struct[key] = parse_iso8601_datetime(value).replace(tzinfo=timezone.utc)
+        elif valueType.lower() == 'decimal':
+            final_struct[key] = value
+        elif valueType.lower() == 'id':
+            match = re.search(value, type_regexes['id'])
+            final_struct[key] = match.group(0) if match else ''
+        elif valueType.lower() == 'instant':
+            if isinstance(value, datetime):
+                final_struct[key] = value.replace(tzinfo=timezone.utc)
+            else:
+                final_struct[key] = final_struct[key] = parse_iso8601_instant(value).replace(tzinfo=timezone.utc)
+        elif valueType.lower() == 'integer':
+            match = re.search(value, type_regexes['integer'])
+            final_struct[key] = int(match.group(0)) if match else 0
+        elif valueType.lower() == 'oid':
+            match = re.search(value, type_regexes['oid'])
+            final_struct[key] = match.group(0) if match else ''
+        elif valueType.lower() == 'positiveInt':
+            match = re.search(value, type_regexes['positiveInt'])
+            final_struct[key] = int(match.group(0)) if match else 0
+        elif valueType.lower() == 'quantity':
+            final_struct[key] = string_to_quantity(value)
+        elif valueType.lower() == 'string':
+            final_struct[key] = value
+        elif valueType.lower() == 'string[]':
+            if not key in final_struct:
+                final_struct[key] = [value]
+            else:
+                final_struct[key].append(value)
+        elif valueType.lower() == 'time':
+            if isinstance(time):
+                final_struct[key] = value
+            else:
+                final_struct[key] = parse_iso8601_time(value)
+        elif valueType.lower() == 'unsignedInt':
+            match = re.search(value, type_regexes['unsignedInt'])
+            final_struct[key] = int(match.group(0)) if match else 0
+        elif valueType.lower() == 'uri':
+            final_struct[key] = value
+        elif valueType.lower() == 'url':
+            final_struct[key] = value
+        elif valueType.lower() == 'uuid':
+            match = re.search(value, type_regexes['uuid'])
+            final_struct[key] = match.group(0) if match else ''
+        elif valueType.lower() == 'coding':
+            if not isinstance(final_struct, list):
+                final_struct = []
+            final_struct.append(value)
+        else:
+            print(f"ERROR: - Rending Value - {key} - {value} - {valueType} - Saw a valueType of '{valueType}' unsupported in current formatting")
+    except ValueError as e:
+        print(e)
+    return final_struct
+        
+def parse_iso8601_date(input_string):
+    # Regular expression to match ISO 8601 format with optional timezone 'Z'
+    pattern = r'(\d{4}-\d{2}-\d{2})'
+    match = re.search(pattern, input_string)
+    # Check if the input string matches the pattern
+    if match:
+        return datetime.strptime(match.group(1), '%Y-%m-%d')
+    else:
+        raise ValueError(f"Input string '{input_string}' is not in the valid ISO 8601 date format")
+
+def parse_iso8601_datetime(input_string):
+    # Regular expression to match ISO 8601 format with optional timezone 'Z'
+    pattern = r'(\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(Z)?)?)'
+    match = re.search(pattern, input_string)
+    # Check if the input string matches the pattern
+    if match:
+        # Convert to datetime object
+        if input_string.endswith('Z'):
+            # If it has 'Z', convert to UTC
+            try:
+                return datetime.strptime(match.group(1), '%Y-%m-%dT%H:%M:%S').replace(tzinfo=timezone.utc)
+            except ValueError: # If it fails (because the time part is missing), parse the date-only format and set time to midnight
+                try:
+                    parsed_date = datetime.strptime(match.group(1), '%Y-%m-%d')
+                    parsed_datetime = parsed_date.replace(hour=0, minute=0, second=0)
+                    return parsed_datetime
+                except ValueError: # Neither format worked so catch an entire error
+                    raise ValueError(f"Input string '{input_string}' is not in the valid ISO 8601 format date or datetime format")
+        else:
+            # Otherwise, just convert without timezone
+            try:
+                return datetime.strptime(match.group(1), '%Y-%m-%dT%H:%M:%S').replace(tzinfo=timezone.utc)
+            except ValueError: # If it fails (because the time part is missing), parse the date-only format and set time to midnight
+                try:
+                    parsed_date = datetime.strptime(match.group(1), '%Y-%m-%d')
+                    parsed_datetime = parsed_date.replace(hour=0, minute=0, second=0)
+                    return parsed_datetime
+                except ValueError: # Neither format worked so catch an entire error
+                    raise ValueError(f"Input string '{input_string}' is not in the valid ISO 8601 format date or datetime format")
+    else:
+        raise ValueError(f"Input string '{input_string}' is not in the valid ISO 8601 format date or datetime format")
+    
+def parse_iso8601_instant(input_string):
+    # Regular expression to match ISO 8601 instant format with optional milliseconds and 'Z'
+    pattern = r'(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?(Z)?)'
+    match = re.search(pattern, input_string)
+    # Check if the input string matches the pattern
+    if match:
+        # If it ends with 'Z', it's UTC
+        if input_string.endswith('Z'):
+            if '.' in input_string:
+                # With milliseconds
+                return datetime.strptime(match.group(1), '%Y-%m-%dT%H:%M:%S.%f').replace(tzinfo=timezone.utc)
+            else:
+                # Without milliseconds
+                return datetime.strptime(match.group(1), '%Y-%m-%dT%H:%M:%S').replace(tzinfo=timezone.utc)
+        else:
+            if '.' in input_string:
+                # With milliseconds
+                return datetime.strptime(match.group(1), '%Y-%m-%dT%H:%M:%S.%f')
+            else:
+                # Without milliseconds
+                return datetime.strptime(match.group(1), '%Y-%m-%dT%H:%M:%S')
+    else:
+        raise ValueError(f"Input string '{input_string}' is not in the valid ISO 8601 instant format")
+    
+def parse_iso8601_time(input_string):
+    # Regular expression to match the time format HH:MM:SS or HH:MM:SS.ssssss
+    pattern = r'((?:[01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]{1,9})?)'
+    match = re.search(pattern, input_string)
+    # Check if the input string matches the pattern
+    if match:
+        # Parse the time
+        time_parts = match.group(1).split(':')
+        hours = int(time_parts[0])
+        minutes = int(time_parts[1])
+        seconds = float(time_parts[2])  # This can handle the fractional part
+        
+        return datetime.time(hour=hours, minute=minutes, second=int(seconds), microsecond=int((seconds % 1) * 1_000_000))
+    else:
+        raise ValueError(f"Input string '{input_string}' is not in the valid time format")
+    
+def parse_flexible_address(address):
+    # Attempt to capture postal code, which is often at the end and typically numeric (though it may vary internationally)
+    postal_code_pattern = r'(?P<postalCode>\d{5}(?:-\d{4})?|)'
+    
+    # State is typically a two-letter code (though this may vary internationally as well)
+    state_pattern = r'(?P<state>[A-Za-z]{2}|)'
+    
+    # This captures a country after a comma (or space-separated) if it's present
+    country_pattern = r'(?:\s*(?P<country>[\w\s]+|))?$'
+    
+    # Compile the full pattern to match the postal code, state, and country
+    full_pattern = rf'^(?P<line>.*?)\^(?P<city>.*?)\^(?P<district>.*?)\^{state_pattern}\^{postal_code_pattern}\^{country_pattern}'
+    
+    match = re.search(full_pattern, address)
+    
+    if match:
+        # Extract the components found in the regex
+        result = {k: v for k, v in match.groupdict().items() if v not in ("", None)}
+        if not result:
+            return None
+        #Assign the line as an array of 1
+        if result['line'] and isinstance(result['line'], str):
+            result['line'] = [result['line']]
+        return result
+    else:
+        return None  # Return None if the format doesn't match
+    
+def caret_delimited_string_to_codeableconcept(caret_delimited_str):
+    # Split the string by '~' to separate multiple codings
+    codings = caret_delimited_str.split('~')
+    
+    # Initialize the CodeableConcept dictionary
+    codeable_concept = {"coding": []}
+    
+    # Loop over each coding section
+    for coding_str in codings:
+        # Split each part by '^' to get system, code, and display (optionally text at the end)
+        parts = coding_str.split('^')
+        
+        # Create a coding dictionary from the components
+        coding_dict = {}
+        if len(parts) > 0:
+            coding_dict['system'] = parts[0] if parts[0] else ''
+        if len(parts) > 1:
+            coding_dict['code'] = parts[1] if parts[1] else ''
+        if len(parts) > 2:
+            coding_dict['display'] = parts[2] if parts[2] else ''
+        
+        # Add coding to the 'coding' list in CodeableConcept
+        codeable_concept['coding'].append(coding_dict)
+    
+    # Check if the last element contains 'text' (for the entire CodeableConcept)
+    if len(parts) == 4:
+        codeable_concept['text'] = parts[3]
+    return codeable_concept
+
+def caret_delimited_string_to_coding(caret_delimited_str):
+    # Split the string by '~' to separate multiple codings
+    
+    # Initialize the CodeableConcept dictionary
+    coding = {}
+    
+    parts = caret_delimited_str.split('^')
+    
+    # Create a coding dictionary from the components
+    if len(parts) > 0:
+        coding['system'] = parts[0] if parts[0] else ''
+    if len(parts) > 1:
+        coding['code'] = parts[1] if parts[1] else ''
+    if len(parts) > 2:
+        coding['display'] = parts[2] if parts[2] else ''
+    return coding
+
+def string_to_quantity(quantity_str):
+    # Split the string into value and unit by whitespace
+    parts = quantity_str.split('^',maxsplit=1)
+    
+    # Initialize the Quantity dictionary
+    quantity = {}
+    
+    # First part is the value (convert to float)
+    if len(parts) > 0:
+        quantity['value'] = float(parts[0])
+    
+    # Second part is the unit (if present)
+    if len(parts) > 1:
+        quantity['unit'] = parts[1]
+        quantity['system'] = 'http://unitsofmeasure.org'
+        quantity['code'] = parts[1]
+    
+    
+    return quantity

fhir_sheets/core/read_input.py

@@ -0,0 +1,99 @@
+import openpyxl
+
+# Function to read the xlsx file and access specific sheets
+def read_xlsx_and_process(file_path):
+    # Load the workbook
+    workbook = openpyxl.load_workbook(file_path)
+
+    # Example of accessing specific sheets
+    if 'ResourceDefinitions' in workbook.sheetnames:
+        sheet = workbook['ResourceDefinitions']
+        resource_definition_entities = process_sheet_resource_definitions(sheet)
+
+    if 'ResourceLinks' in workbook.sheetnames:
+        sheet = workbook['ResourceLinks']
+        resource_link_entities = process_sheet_resource_links(sheet)
+
+    if 'PatientData' in workbook.sheetnames:
+        sheet = workbook['PatientData']
+        patient_data_entities, num_entries = process_sheet_patient_data(sheet, resource_definition_entities)
+    
+    return {
+        "resource_definition_entities": resource_definition_entities,
+        "resource_link_entities": resource_link_entities,
+        "patient_data_entities": patient_data_entities,
+        "num_entries": num_entries
+    }
+
+
+# Function to process the specific sheet with 'Entity Name', 'ResourceType', and 'Profile(s)'
+def process_sheet_resource_definitions(sheet):
+    resource_definitions = []
+    headers = [cell.value for cell in next(sheet.iter_rows(min_row=1, max_row=1))]  # Get headers
+
+    for row in sheet.iter_rows(min_row=3, values_only=True):
+        row_data = dict(zip(headers, row))  # Create a dictionary for each row
+        if all(cell is None or cell == "" for cell in row_data.values()):
+            continue
+        # Split 'Profile(s)' column into a list of URLs
+        if row_data.get("Profile(s)"):
+            row_data["Profile(s)"] = [url.strip() for url in row_data["Profile(s)"].split(",")]
+
+        resource_definitions.append(row_data)
+
+    return resource_definitions
+
+# Function to process the specific sheet with 'OriginResource', 'ReferencePath', and 'DestinationResource'
+def process_sheet_resource_links(sheet):
+    resource_links = []
+    headers = [cell.value for cell in next(sheet.iter_rows(min_row=1, max_row=1))]  # Get headers
+    for row in sheet.iter_rows(min_row=3, values_only=True):
+        row_data = dict(zip(headers, row))  # Create a dictionary for each row
+        if all(cell is None or cell == "" for cell in row_data):
+            continue
+        resource_links.append(row_data)
+
+    return resource_links
+
+# Function to process the "PatientData" sheet
+def process_sheet_patient_data(sheet, resource_definition_entities):
+    # Initialize the dictionary to store the processed data
+    patient_data = {}
+    # Extract the data from the first 6 rows (Entity To Query, JsonPath, etc.)
+    for col in sheet.iter_cols(min_row=1, max_row=6, min_col=3, values_only=True):  # Start from 3rd column
+        if all(entry is None for entry in col):
+            continue
+        entity_name = col[0]  # The entity name comes from the first row (Entity To Query)
+        field_name = col[5]  #The "Data Element" comes from the fifth row
+        if (entity_name is None or entity_name == "") and (field_name is not None and field_name != ""):
+            print(f"WARNING: - Reading Patient Data Issue - {field_name} - 'Entity To Query' cell missing for column labelled '{field_name}', please provide entity name from the ResourceDefinitions tab.")
+
+        if entity_name not in [entry['Entity Name'] for entry in resource_definition_entities]:
+            print(f"WARNING: - Reading Patient Data Issue - {field_name} - 'Entity To Query' cell has entity named '{entity_name}', however, the ResourceDefinition tab has no matching resource. Please provide a corresponding entry in the ResourceDefinition tab.")
+        # Create structure for this entity if not already present
+        if entity_name not in patient_data:
+            patient_data[entity_name] = {}
+
+        # Add jsonpath, valuesets, and initialize an empty list for 'values'
+        if field_name not in patient_data[entity_name]:
+            patient_data[entity_name][field_name] = {
+                "jsonpath": col[1],  # JsonPath from the second row
+                "valueType": col[2], # Value Type from the third row
+                "valuesets": col[3], # Value Set from the fourth row
+                "values": []         # Initialize empty list for actual values
+            }
+    
+    # Now process the rows starting from the 6th row (the actual data entries)
+    num_entries = 0
+    for row in sheet.iter_rows(min_row=7, values_only=True):  # Start from row 6 for actual data
+        if all(cell is None for cell in row):
+            continue
+        num_entries = num_entries + 1
+        entity_name = row[0]  # The entity name comes from the first column of each row
+        for i, value in enumerate(row[2:], start=1):  # Iterate through the values in the columns
+            entity_name = sheet.cell(row=1, column=i + 2).value
+            field_name = sheet.cell(row=6, column=i + 2).value  # Get the Data Element for this column
+            if entity_name in patient_data and field_name in patient_data[entity_name]:
+                # Append the actual data values to the 'values' array
+                patient_data[entity_name][field_name]["values"].append(value)
+    return patient_data, num_entries

fhir_sheets/core/special_values.py

@@ -0,0 +1,360 @@
+
+from . import conversion
+
+from abc import ABC, abstractmethod
+
+# Define an abstract base class
+class AbstractCustomValueHandler(ABC):
+    
+    @abstractmethod
+    def assign_value(self, json_path, resource_definition, entity_definition, final_struct, key, value):
+        pass
+    
+class PatientRaceExtensionValueHandler(AbstractCustomValueHandler):
+    omb_categories = {
+      "american indian or alaska native" : {
+        "url" : "ombCategory",
+        "valueCoding" : {
+          "system" : "urn:oid:2.16.840.1.113883.6.238",
+          "code" : "1002-5",
+          "display" : "American Indian or Alaska Native"
+          }
+      },
+      "asian" : {
+        "url" : "ombCategory",
+        "valueCoding" : {
+          "system" : "urn:oid:2.16.840.1.113883.6.238",
+          "code" : "2028-9",
+          "display" : "Asian"
+          }
+      },
+      "black or african american" : {
+        "url" : "ombCategory",
+        "valueCoding" : {
+          "system" : "urn:oid:2.16.840.1.113883.6.238",
+          "code" : "2054-5",
+          "display" : "Black or African American"
+          }
+      },
+      "native hawaiian or other pacific islander" : {
+        "url" : "ombCategory",
+        "valueCoding" : {
+          "system" : "urn:oid:2.16.840.1.113883.6.238",
+          "code" : "2054-5",
+          "display" : "Native Hawaiian or Other Pacific Islander"
+          }  
+      },
+      "white" : {
+        "url" : "ombCategory",
+        "valueCoding" : {
+          "system" : "urn:oid:2.16.840.1.113883.6.238",
+          "code" : "2106-3",
+          "display" : "White"
+        }
+      }
+    }
+    
+    initial_race_json = {
+      "extension" : [
+        {
+          "$ombCategory"
+        },
+        {
+          "url" : "text",
+          "valueString" : "$text"
+        }
+      ],
+      "url" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-race"
+    }
+    #Create an ombcategory and detailed section of race extension
+    def assign_value(self, json_path, resource_definition, entity_definition, final_struct, key, value):
+        #Retrieve the race extension if it exists; make it if it does not.
+        if 'extension' not in final_struct:
+            final_struct['extension'] = []
+        race_block = utilFindExtensionWithURL(final_struct['extension'], 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-race')
+        if race_block is None:
+            race_block = self.initial_race_json
+            final_struct['extension'].append(race_block)
+        for race_key, race_structure in self.omb_categories.items():
+            if value.strip().lower() == race_key:
+                # Replace $ombCategory in the extension list
+                for i, item in enumerate(race_block["extension"]):
+                    if isinstance(item, set) and "$ombCategory" in item:
+                        # Replace the set with the new structure
+                        race_block["extension"][i] = race_structure
+                    elif isinstance(item, dict) and item.get("valueString") == "$text":
+                        item['valueString'] = race_key
+                return final_struct
+        pass
+
+class PatientEthnicityExtensionValueHandler(AbstractCustomValueHandler):
+    omb_categories = {
+      "Hispanic or Latino" : {
+        "url" : "ombCategory",
+        "valueCoding" : {
+          "system" : "urn:oid:2.16.840.1.113883.6.238",
+          "code" : "2135-2",
+          "display" : "Hispanic or Latino"
+          }
+      },
+      "Non Hispanic or Latino" : {
+        "url" : "ombCategory",
+        "valueCoding" : {
+          "system" : "urn:oid:2.16.840.1.113883.6.238",
+          "code" : "2186-5",
+          "display" : "Not Hispanic or Latino"
+          }
+      },
+      "Not Hispanic or Latino" : {
+        "url" : "ombCategory",
+        "valueCoding" : {
+          "system" : "urn:oid:2.16.840.1.113883.6.238",
+          "code" : "2186-5",
+          "display" : "Not Hispanic or Latino"
+          }
+      }
+    }
+    
+    initial_ethnicity_json = {
+      "extension" : [
+        {
+          "$ombCategory"
+        },
+        {
+          "url" : "text",
+          "valueString" : "$text"
+        }
+      ],
+      "url" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity"
+    }
+    #Create an ombcategory and detailed section of ethnicitiy extension
+    def assign_value(self, json_path, resource_definition, entity_definition, final_struct, key, value):
+        #Retrieve the ethncitiy extension if it exists; make it if it does not.
+        if 'extension' not in final_struct:
+            final_struct['extension'] = []
+        ethnicity_block = utilFindExtensionWithURL(final_struct['extension'], 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity')
+        if ethnicity_block is None:
+            ethnicity_block = self.initial_ethnicity_json
+            final_struct['extension'].append(ethnicity_block)
+        for race_key, race_structure in self.omb_categories.items():
+            if value.strip().lower() == race_key.strip().lower():
+                # Replace $ombCategory in the extension list
+                for i, item in enumerate(ethnicity_block["extension"]):
+                    if isinstance(item, set) and "$ombCategory" in item:
+                        # Replace the set with the new structure
+                        ethnicity_block["extension"][i] = race_structure
+                    elif isinstance(item, dict) and item.get("valueString") == "$text":
+                        item['valueString'] = race_key
+                return final_struct
+        pass
+      
+class PatientBirthSexExtensionValueHandler(AbstractCustomValueHandler):
+    birth_sex_block = {
+      "url" : "http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex",
+      "valueCode" : "$value"
+    }
+    #Assigna birthsex extension
+    def assign_value(self, json_path, resource_definition, entity_definition, final_struct, key, value):
+        #Retrieve the birthsex extension if it exists; make it if it does not.
+        if 'extension' not in final_struct:
+            final_struct['extension'] = []
+        birthsex_block = utilFindExtensionWithURL(final_struct['extension'], 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity')
+        if birthsex_block is None:
+            birthsex_block = self.birth_sex_block
+            birthsex_block['valueCode'] = value
+            final_struct['extension'].append(birthsex_block)
+        pass
+      
+class PatientMRNIdentifierValueHandler(AbstractCustomValueHandler):
+    patient_mrn_block = {
+      "use" : "usual",
+      "type" : {
+        "coding" : [
+          {
+            "system" : "http://terminology.hl7.org/CodeSystem/v2-0203",
+            "code" : "MR",
+            "display" : "Medical Record Number"
+          }
+        ],
+        "text" : "Medical Record Number"
+      },
+      "system" : "$system",
+      "value" : "$value"
+    }
+    #Assign a MRN identifier
+    def assign_value(self, json_path, resource_definition, entity_definition, final_struct, key, value):
+        #Retrieve the MRN identifier if it exists; make it if it does not.
+        target_identifier = self.patient_mrn_block
+        new_identifier = True
+        if 'identifier' not in final_struct:
+          final_struct['identifier'] = []
+        for identifier in final_struct['identifier']:
+          if 'type' in identifier:
+            for coding in identifier['type']['coding']:
+              if coding['code'] == 'MR':
+                target_identifier = identifier
+                new_identifier = False
+        if new_identifier:
+          final_struct['identifier'].append(target_identifier)
+        target_identifier[key] = value
+        pass
+      
+class PatientSSNIdentifierValueHandler(AbstractCustomValueHandler):
+    patient_mrn_block = {
+      "use" : "usual",
+      "type" : {
+        "coding" : [
+          {
+            "system" : "http://terminology.hl7.org/CodeSystem/v2-0203",
+            "code" : "SS"
+          }
+        ],
+        "text" : "Social Security Number"
+      },
+      "system" : "$system",
+      "value" : "$value"
+    }
+    #Assign a MRN identifier
+    def assign_value(self, json_path, resource_definition, entity_definition, final_struct, key, value):
+        #Retrieve the MRN identifier if it exists; make it if it does not.
+        target_identifier = self.patient_mrn_block
+        new_identifier = True
+        if 'identifier' not in final_struct:
+          final_struct['identifier'] = []
+        for identifier in final_struct['identifier']:
+          if 'type' in identifier:
+            for coding in identifier['type']['coding']:
+              if coding['code'] == 'SS':
+                target_identifier = identifier
+                new_identifier = False
+        if new_identifier:
+          final_struct['identifier'].append(target_identifier)
+        target_identifier[key] = value
+        pass
+      
+class OrganizationIdentiferNPIValueHandler(AbstractCustomValueHandler):
+    npi_identifier_block = {
+      "system" : "http://hl7.org.fhir/sid/us-npi",
+      "value" : "$value"
+    }
+    #Assigna birthsex extension
+    def assign_value(self, json_path, resource_definition, entity_definition, final_struct, key, value):
+        #Retrieve the birthsex extension if it exists; make it if it does not.
+        if 'identifier' not in final_struct:
+            final_struct['identifier'] = []
+        identifier_block = next((entry for entry in final_struct['identifier'] if entry['system'] == "http://hl7.org.fhir/sid/us-npi"), None)
+        if identifier_block is None:
+          identifier_block = self.npi_identifier_block
+          final_struct['identifier'].append(identifier_block)
+        identifier_block['value'] = str(value)
+        pass
+      
+class OrganizationIdentiferCLIAValueHandler(AbstractCustomValueHandler):
+    clia_identifier_block = {
+      "system" : "urn:oid:2.16.840.1.113883.4.7",
+      "value" : "$value"
+    }
+    #Assign a birthsex extension
+    def assign_value(self, json_path, resource_definition, entity_definition, final_struct, key, value):
+        #Retrieve the birthsex extension if it exists; make it if it does not.
+        if 'identifier' not in final_struct:
+            final_struct['identifier'] = []
+        identifier_block = next((entry for entry in final_struct['identifier'] if entry['system'] == "urn:oid:2.16.840.1.113883.4.7"), None)
+        if identifier_block is None:
+          identifier_block = self.clia_identifier_block
+          final_struct['identifier'].append(identifier_block)
+        identifier_block['value'] = str(value)
+        pass
+      
+class PractitionerIdentiferNPIValueHandler(AbstractCustomValueHandler):
+    npi_identifier_block = {
+      "system" : "http://hl7.org.fhir/sid/us-npi",
+      "value" : "$value"
+    }
+    #Assigna birthsex extension
+    def assign_value(self, json_path, resource_definition, entity_definition, final_struct, key, value):
+        #Retrieve the birthsex extension if it exists; make it if it does not.
+        if 'identifier' not in final_struct:
+            final_struct['identifier'] = []
+        identifier_block = next((entry for entry in final_struct['identifier'] if entry['system'] == "http://hl7.org.fhir/sid/us-npi"), None)
+        if identifier_block is None:
+          identifier_block = self.npi_identifier_block
+          final_struct['identifier'].append(identifier_block)
+        identifier_block['value'] = value
+        pass
+      
+class ObservationComponentHandler(AbstractCustomValueHandler):
+    pulse_oximetry_oxygen_flow_rate = {
+      "code" : {
+        "coding" : [
+          {
+            "system" : "http://loinc.org",
+            "code" : "3151-8",
+            "display" : "Inhaled oxygen flow rate"
+          }
+        ],
+        "text" : "Inhaled oxygen flow rate"
+      }
+    }
+    pulse_oximetry_oxygen_concentration = {
+      "code" : {
+        "coding" : [
+          {
+            "system" : "http://loinc.org",
+            "code" : "3150-0",
+            "display" : "Inhaled oxygen concentration"
+          }
+        ],
+        "text" : "Inhaled oxygen concentration"
+      }
+    }
+    #Find the appropriate component for the observaiton; then call build_structure again to continue the drill down
+    def assign_value(self, json_path, resource_definition, entity_definition, final_struct, key, value):
+        #Check to make sure the component part exists
+        if 'component' not in final_struct:
+          final_struct['component'] = []
+        components = final_struct['component']
+        #Look through the qualifier parts.
+        parts = json_path.split('.')
+        key_part = parts[1][:parts[1].index('[')]
+        qualifier = parts[1][parts[1].index('[')+1:parts[1].index(']')]
+        qualifier_condition = qualifier.split('=')
+        
+        target_component = None
+        if qualifier_condition[0] == 'code' and qualifier_condition[1] == '3151-8':
+          target_component = findComponentWithCoding(components, '3151-8') or self.pulse_oximetry_oxygen_flow_rate
+          if target_component is self.pulse_oximetry_oxygen_flow_rate:
+            components.append(target_component)
+        if qualifier_condition[0] == 'code' and qualifier_condition[1] == '3150-0':
+          target_component = findComponentWithCoding(components, '3150-0') or self.pulse_oximetry_oxygen_concentration
+          if target_component is self.pulse_oximetry_oxygen_concentration:
+            components.append(target_component)
+        #Recurse back down into 
+        return conversion.build_structure(target_component, '.'.join(parts[2:]), resource_definition, entity_definition, parts[2:], value, parts[:2])
+        pass
+
+def utilFindExtensionWithURL(extension_block, url):
+    for extension in extension_block:
+        if "url" in extension and extension['url'] == url:
+            return extension
+        return None
+
+def findComponentWithCoding(components, code):
+  return next((component for component in components if any(coding['code'] == code for coding in component['code']['coding'])), None)
+
+#Data dictionary of jsonpaths to match vs classes that need to be called
+custom_handlers = {
+    "Patient.extension[Race].ombCategory": PatientRaceExtensionValueHandler(),
+    "Patient.extension[Ethnicity].ombCategory": PatientEthnicityExtensionValueHandler(),
+    "Patient.extension[Birthsex].value": PatientBirthSexExtensionValueHandler(),
+    "Patient.identifier[type=MR].system": PatientMRNIdentifierValueHandler(),
+    "Patient.identifier[type=MR].value": PatientMRNIdentifierValueHandler(),
+    "Patient.identifier[type=MRN].system": PatientMRNIdentifierValueHandler(),
+    "Patient.identifier[type=MRN].value": PatientMRNIdentifierValueHandler(),
+    "Patient.identifier[type=SSN].system": PatientSSNIdentifierValueHandler(),
+    "Patient.identifier[type=SSN].value": PatientSSNIdentifierValueHandler(),
+    "Organization.identifier[system=NPI].value": OrganizationIdentiferNPIValueHandler(),
+    "Organization.identifier[system=CLIA].value": OrganizationIdentiferCLIAValueHandler(),
+    "Practitioner.identifier[system=NPI].value": PractitionerIdentiferNPIValueHandler(),
+    "Observation.component[": ObservationComponentHandler()
+}

fhir_sheets/core/util.py

@@ -0,0 +1 @@
+resource_

fhir_sheets-1.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fhir_sheets-1.1.0.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.3
+Name: fhir-sheets
+Version: 1.1.0
+Summary: FhirSheetsiIs a command-line tool that reads an Excel file in FHIR cohort format and generates FHIR bundle JSON files from it. Each row in the template Excel file is used to create an individual JSON file, outputting them to a specified folder.
+Author: Michael Riley
+Author-email: Michael.Riley@gtri.gatech.edu
+Requires-Python: >=3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: et-xmlfile (==1.1.0)
+Requires-Dist: jsonpath-ng (==1.6.1)
+Requires-Dist: openpyxl (==3.1.5)
+Requires-Dist: orjson (==3.10.7)
+Requires-Dist: ply (==3.11)

fhir_sheets-1.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+fhir_sheets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fhir_sheets/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fhir_sheets/cli/fhirsheets.py,sha256=EOC42o4nJ49G8QDGxb3PeNMqB0F05OV061LifC1dPq4,2721
+fhir_sheets/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fhir_sheets/core/conversion.py,sha256=_N5Zo5Qb_vzUuoi-cMX1P-ELAOcDQQMaNo1BJBLu05Q,18170
+fhir_sheets/core/fhir_formatting.py,sha256=kGnXZe3RusafxuCz_tp4bBZbdIAFWXJ4ZRrnG2iQYfo,13011
+fhir_sheets/core/read_input.py,sha256=9zD7B61se_r9rkFYmKBRoWgFqYo9YJ8eIYFsm7Jn9VM,5312
+fhir_sheets/core/special_values.py,sha256=KwpJLggH3-BSH8NrGtRTtVBz0fl-iH7swxPwBb3iMx4,15513
+fhir_sheets/core/util.py,sha256=gudEPi_xTDC9YHqUlGEkn_tA26HbhNjuqGgjtuOEINk,9
+fhir_sheets-1.1.0.dist-info/LICENSE,sha256=Qv2ilebwoUtMJnRsZwRy729xS5JZQzLauJ0tQzkAkTA,1088
+fhir_sheets-1.1.0.dist-info/METADATA,sha256=0Cl4h-ONolHWJOEdxmATNtq8Oe0l557wwrzjNRdn8ws,666
+fhir_sheets-1.1.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+fhir_sheets-1.1.0.dist-info/RECORD,,

fhir_sheets-1.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.3
+Root-Is-Purelib: true
+Tag: py3-none-any