fhir-sheets 1.1.0__tar.gz → 1.2.0__tar.gz

{fhir_sheets-1.1.0 → fhir_sheets-1.2.0}/PKG-INFO

@@ -1,12 +1,14 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 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.
+Version: 1.2.0
+Summary: FhirSheets is 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.
+License-File: LICENSE
 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
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: et-xmlfile (==1.1.0)
 Requires-Dist: jsonpath-ng (==1.6.1)
 Requires-Dist: openpyxl (==3.1.5)

{fhir_sheets-1.1.0 → fhir_sheets-1.2.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "fhir-sheets"
-version = "1.1.0"
-description = "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."
+version = "1.2.0"
+description = "FhirSheets is 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."
 authors = ["Michael Riley <Michael.Riley@gtri.gatech.edu>"]
 packages = [{include = "fhir_sheets", from = "src"}]
 

fhir_sheets-1.1.0/src/fhir_sheets/cli/fhirsheets.py → fhir_sheets-1.2.0/src/fhir_sheets/cli/main.py

@@ -5,6 +5,7 @@ import argparse
 import orjson
 import json
 from pathlib import Path
+from pprint import pprint
 
 def find_sets(d, path=""):
     if isinstance(d, dict):
@@ -27,16 +28,14 @@ def main(input_file, output_folder):
         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']
-    
+    resource_definition_entities, resource_link_entities, cohort_data = read_input.read_xlsx_and_process(input_file)
+    pprint(cohort_data)
     #For each index of patients
-    for i in range(0,data['num_entries']):
+    for i in range(0,cohort_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)
+        fhir_bundle = conversion.create_transaction_bundle(resource_definition_entities, resource_link_entities, cohort_data, i)
         # Step 3: Write the processed data to the output file
         find_sets(fhir_bundle)
         json_string = orjson.dumps(fhir_bundle)

{fhir_sheets-1.1.0 → fhir_sheets-1.2.0}/src/fhir_sheets/core/conversion.py

@@ -1,18 +1,23 @@
+from typing import Any, Dict, List
 import uuid
 from jsonpath_ng.jsonpath import Fields, Slice, Where
 from jsonpath_ng.ext import parse as parse_ext
+
+from .model.cohort_data_entity import CohortData, FieldEntry
+from .model.resource_definition_entity import ResourceDefinition
+from .model.resource_link_entity import ResourceLink
 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):
+def create_transaction_bundle(resource_definition_entities: List[ResourceDefinition], resource_link_entities: List[ResourceLink], cohort_data: CohortData, index = 0):
     root_bundle = initialize_bundle()
     created_resources = {}
     for resource_definition in resource_definition_entities:
-        entity_name = resource_definition['Entity Name']
+        entity_name = resource_definition.entity_name
         #Create and collect fhir resources
-        fhir_resource = create_fhir_resource(resource_definition, patient_data, index)
+        fhir_resource = create_fhir_resource(resource_definition, cohort_data, index)
         created_resources[entity_name] = fhir_resource
     #Link resources after creation
     add_default_resource_links(created_resources, resource_link_entities)
@@ -31,36 +36,35 @@ def initialize_bundle():
     root_bundle['entry'] = []
     return root_bundle
 
+#Initialize a resource from a resource definition. Adding basic information all resources need
+def initialize_resource(resource_definition):
+    initial_resource = {}
+    initial_resource['resourceType'] = resource_definition.resource_type.strip()
+    initial_resource['id'] = str(uuid.uuid4()).strip()
+    if resource_definition.profiles:
+        initial_resource['meta'] = {
+            'profile': resource_definition.profiles
+        }
+    return initial_resource
+
 # 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):
+def create_fhir_resource(resource_definition: ResourceDefinition, cohort_data: CohortData, index = 0):
     resource_dict = initialize_resource(resource_definition)
     #Get field entries for this entitiy
     try:
-        all_field_entries = patient_data[resource_definition['Entity Name']]
+        all_field_entries = cohort_data.entities[resource_definition.entity_name].fields
     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")
+        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():
+    for field_entry_key, field_entry in all_field_entries.items():
         #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])
+        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.value_type, 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):
+def add_default_resource_links(created_resources: dict, resource_link_entities: List[ResourceLink]):
     default_references = [
         ('allergyintolerance', 'patient', 'patient'),
         ('allergyintolerance', 'practitioner', 'asserter'),
@@ -115,11 +119,11 @@ def add_default_resource_links(created_resources, resource_link_entities):
             originResourceEntityName = resource_counts[sourceType]['singletonEntityName']
             destinationResourceEntityName = resource_counts[destinationType]['singletonEntityName']
             resource_link_entities.append(
-                {
+                ResourceLink({
                     "OriginResource": originResourceEntityName,
                     "DestinationResource": destinationResourceEntityName,
                     "ReferencePath": fieldName
-                }
+                })
             )
     return
         
@@ -143,29 +147,29 @@ def create_resource_links(created_resources, resource_link_entites):
     print("Building resource links")
     for resource_link_entity in resource_link_entites:
         try:
-            origin_resource = created_resources[resource_link_entity['OriginResource']]
+            origin_resource = created_resources[resource_link_entity.origin_resource]
         except KeyError:
-            print(f"WARNING: In ResourceLinks tab, found a Origin Resource of : {resource_link_entity['OriginResource']}  but no such entity found in PatientData")
+            print(f"WARNING: In ResourceLinks tab, found a Origin Resource of : {resource_link_entity.origin_resource}  but no such entity found in PatientData")
             continue
         try:
-            destination_resource = created_resources[resource_link_entity['DestinationResource']]
+            destination_resource = created_resources[resource_link_entity.destination_resource]
         except KeyError:
-            print(f"WARNING: In ResourceLinks tab, found a Desitnation Resource  of : {resource_link_entity['DestinationResource']}  but no such entity found in PatientData")
+            print(f"WARNING: In ResourceLinks tab, found a Desitnation Resource  of : {resource_link_entity.destination_resource}  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())
+        destination_resource_type = created_resources[resource_link_entity.destination_resource]['resourceType']
+        destination_resource_id = created_resources[resource_link_entity.destination_resource]['id']
+        link_tuple = (created_resources[resource_link_entity.origin_resource]['resourceType'].strip().lower(),
+                      created_resources[resource_link_entity.destination_resource]['resourceType'].strip().lower(),
+                      resource_link_entity.reference_path.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()] = []
+            if resource_link_entity.reference_path.strip().lower() not in origin_resource:
+                origin_resource[resource_link_entity.reference_path.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)
+            origin_resource[resource_link_entity.reference_path.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
+            origin_resource[resource_link_entity.reference_path.strip().lower()] = reference_json_block.copy()
+            origin_resource[resource_link_entity.reference_path.strip().lower()]["reference"] = destination_resource_type + "/" + destination_resource_id
     return
     
 def add_resource_to_transaction_bundle(root_bundle, fhir_resource):
@@ -188,7 +192,7 @@ def add_resource_to_transaction_bundle(root_bundle, fhir_resource):
 # 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):
+def create_structure_from_jsonpath(root_struct: Dict, json_path: str, resource_definition: ResourceDefinition, field_entry: FieldEntry, dataType: str, value: Any):
     #Get all dot notation components as seperate 
     if dataType is not None and dataType.strip().lower() == 'string':
         value = str(value)
@@ -198,7 +202,7 @@ def create_structure_from_jsonpath(root_struct, json_path, resource_definition,
         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, [])
+    return build_structure(root_struct, json_path, resource_definition, field_entry, 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):
@@ -211,7 +215,7 @@ def build_structure(current_struct, json_path, resource_definition, entity_defin
     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():
+    if part == '$' or part == resource_definition.resource_type.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)
     
@@ -236,7 +240,7 @@ def build_structure(current_struct, json_path, resource_definition, entity_defin
                 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'])
+        fhir_formatting.assign_value(current_struct, part, value, entity_definition.value_type)
         return current_struct
     
     # If there is a simple qualifier with '['and ']'

fhir_sheets-1.2.0/src/fhir_sheets/core/model/cohort_data_entity.py

@@ -0,0 +1,97 @@
+import pprint
+from typing import Dict, Any, List, Optional
+
+class FieldEntry:
+    def __init__(self, data: Dict[str, Any]):
+        self.jsonpath: Optional[str] = data.get('jsonpath')
+        self.value_type: Optional[str] = data.get('valueType')
+        self.valuesets: Optional[str] = data.get('valuesets')
+        self.values: Optional[List[str]] = data.get('values')
+        
+    def __repr__(self) -> str:
+        return (f"FieldEntry(\n\tjsonpath='{self.jsonpath}',\n\tvalue_type='{self.value_type}', "
+                f"\n\tvaluesets='{self.valuesets}', \n\tvalues={self.values})")
+
+class EntityData:
+    def __init__(self, data: Dict[str, Dict[str, Any]]):
+        """
+        Initializes the EntityData object. Accepts either a dictionary of raw data
+        or a list of FieldEntry objects.
+
+        Args:
+            data (Dict[str, Dict[str, Any]]): A dictionary mapping names to raw field data.
+            entries (List[FieldEntry]): A list of pre-created FieldEntry objects.
+        """
+        self.fields: Dict[str, FieldEntry] = {}
+        for name, field_data in data.items():
+            self.fields[name] = FieldEntry(field_data)
+
+    def __repr__(self) -> str:
+        return f"EntityData(fields=\n{pprint.pformat(self.fields, indent=4)})"
+    
+    def insert(self, name: str, entry: FieldEntry):
+        """
+        Inserts a new FieldEntry into the collection.
+        
+        Args:
+            name (str): The referential name for the field.
+            entry (FieldEntry): The FieldEntry object to insert.
+        """
+        self.fields[name] = entry
+
+    def remove(self, name: str) -> bool:
+        """
+        Removes a FieldEntry by its referential name.
+        
+        Args:
+            name (str): The referential name of the field to remove.
+        
+        Returns:
+            bool: True if the field was removed, False otherwise.
+        """
+        if name in self.fields:
+            del self.fields[name]
+            return True
+        return False
+    
+class CohortData:
+    def __init__(self, data: Dict[str, EntityData] = None):
+        """
+        Initializes the CohortData object.
+
+        Args:
+            data (Dict[str, EntityData]): A dictionary where keys are entity names
+                                          and values are EntityData objects.
+        """
+        self.entities: Dict[str, EntityData] = {}
+        self.num_entries = 0
+        if data:
+            self.entities.update(data)
+            
+    def __repr__(self) -> str:
+        return f"CohortData(entities={self.entities})"
+    
+    def insert_entity(self, name: str, entity_data: EntityData):
+        """
+        Inserts a new EntityData object into the cohort.
+
+        Args:
+            name (str): The name of the entity (e.g., 'PrimaryPatient').
+            entity_data (EntityData): The EntityData object to insert.
+        """
+        self.entities[name] = entity_data
+        
+    def remove_entity(self, name: str) -> bool:
+        """
+        Removes an EntityData object by its name.
+
+        Args:
+            name (str): The name of the entity to remove.
+
+        Returns:
+            bool: True if the entity was removed, False otherwise.
+        """
+        if name in self.entities:
+            del self.entities[name]
+            return True
+        return False

fhir_sheets-1.2.0/src/fhir_sheets/core/model/resource_definition_entity.py

@@ -0,0 +1,20 @@
+from typing import Any, Dict, List, Optional
+
+
+class ResourceDefinition:
+    """
+    A class to represent a Resource Definition for FHIR initialization.
+    """
+    def __init__(self, entity_data: Dict[str, Any]):
+        """
+        Initializes the ResourceLink object from a dictionary.
+
+        Args:
+            data: A dictionary containing 'Entity name', 'ResourceType', and 'Profile(s)'.
+        """
+        self.entity_name = entity_data.get('Entity Name')
+        self.resource_type = entity_data.get('ResourceType')
+        self.profiles = entity_data.get('Profile(s)')
+
+    def __repr__(self) -> str:
+        return f"FhirEntity(entity_name='{self.entity_name}', resource_type='{self.resource_type}', profiles={self.profiles})"

fhir_sheets-1.2.0/src/fhir_sheets/core/model/resource_link_entity.py

@@ -0,0 +1,22 @@
+from typing import Any, Dict
+
+
+class ResourceLink:
+    """
+    A class to represent a Fhir Reference between two resources.
+    """
+    def __init__(self, data: Dict[str, Any]):
+        """
+        Initializes the ResourceLink object from a dictionary.
+
+        Args:
+            data: A dictionary containing 'OriginResource', 'ReferencePath', and 'DestinationResource'.
+        """
+        self.origin_resource = data.get('OriginResource')
+        self.reference_path = data.get('ReferencePath')
+        self.destination_resource = data.get('DestinationResource')
+        
+    def __repr__(self) -> str:
+        return (f"ResourceLink(origin_resource='{self.origin_resource}', "
+                f"reference_path='{self.reference_path}', "
+                f"destination_resource='{self.destination_resource}')")

{fhir_sheets-1.1.0 → fhir_sheets-1.2.0}/src/fhir_sheets/core/read_input.py

@@ -1,5 +1,10 @@
 import openpyxl
 
+from .model.cohort_data_entity import CohortData, EntityData, FieldEntry
+
+from .model.resource_definition_entity import ResourceDefinition
+from .model.resource_link_entity import ResourceLink
+
 # Function to read the xlsx file and access specific sheets
 def read_xlsx_and_process(file_path):
     # Load the workbook
@@ -16,19 +21,15 @@ def read_xlsx_and_process(file_path):
 
     if 'PatientData' in workbook.sheetnames:
         sheet = workbook['PatientData']
-        patient_data_entities, num_entries = process_sheet_patient_data(sheet, resource_definition_entities)
+        cohort_data = 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
-    }
+    return resource_definition_entities, resource_link_entities, cohort_data
 
 
 # Function to process the specific sheet with 'Entity Name', 'ResourceType', and 'Profile(s)'
 def process_sheet_resource_definitions(sheet):
     resource_definitions = []
+    resource_definition_entities = []
     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):
@@ -38,27 +39,30 @@ def process_sheet_resource_definitions(sheet):
         # 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_definition_entities.append(ResourceDefinition(row_data))
         resource_definitions.append(row_data)
 
-    return resource_definitions
+    return resource_definition_entities
 
 # Function to process the specific sheet with 'OriginResource', 'ReferencePath', and 'DestinationResource'
 def process_sheet_resource_links(sheet):
     resource_links = []
+    resource_link_entities = []
     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)
+        resource_link_entities.append(ResourceLink(row_data))
 
-    return resource_links
+    return resource_link_entities
 
 # 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 = {}
+    cohort_data = CohortData()
     # 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):
@@ -68,20 +72,23 @@ def process_sheet_patient_data(sheet, resource_definition_entities):
         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]:
+        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] = {}
+            cohort_data.insert_entity(entity_name, EntityData({}))
 
         # 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] = {
+            field_data = {
                 "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
             }
+            patient_data[entity_name][field_name] = field_data
+            cohort_data.entities[entity_name].insert(field_name, FieldEntry(field_data))
     
     # Now process the rows starting from the 6th row (the actual data entries)
     num_entries = 0
@@ -95,5 +102,6 @@ def process_sheet_patient_data(sheet, resource_definition_entities):
             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
+                cohort_data.entities[entity_name].fields[field_name].values.append(value)
+    cohort_data.num_entries = num_entries
+    return cohort_data