fhir-sheets 2.1.6__py3-none-any.whl

fhir_sheets/core/fhir_formatting.py

@@ -0,0 +1,279 @@
+import re
+import datetime
+
+#Dictionary of regexes
+type_regexes = {
+    'code': r'[^\s]+( [^\s]+)*',
+    'decimal': r'-?(0|[1-9][0-9]{0,17})(\.[0-9]{1,17})?([eE][+-]?[0-9]{1,9}})?',
+    'id': r'[A-Za-z0-9\-\.]{1,64}',
+    'integer': r'[0]|[-+]?[1-9][0-9]*',
+    'oid': r'urn:oid:[0-2](\.(0|[1-9][0-9]*))+',
+    'positiveInt': r'[1-9][0-9]*',
+    'unsignedInt': r'[0]|([1-9][0-9]*)',
+    'uuid': r'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.datetime):
+                final_struct[key] = value.date()
+            elif isinstance(value, str):
+                final_struct[key] = parse_iso8601_date(value).replace(tzinfo=datetime.timezone.utc)
+        elif valueType.lower() == 'datetime':
+            if isinstance(value, datetime.datetime):
+                final_struct[key] = value.replace(tzinfo=datetime.timezone.utc)
+            else:
+                final_struct[key] = parse_iso8601_datetime(value).replace(tzinfo=datetime.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.datetime):
+                final_struct[key] = value.replace(tzinfo=datetime.timezone.utc)
+            else:
+                final_struct[key] = final_struct[key] = parse_iso8601_instant(value).replace(tzinfo=datetime.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(value, datetime.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.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.datetime.strptime(match.group(1), '%Y-%m-%dT%H:%M:%S').replace(tzinfo=datetime.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.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.datetime.strptime(match.group(1), '%Y-%m-%dT%H:%M:%S').replace(tzinfo=datetime.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.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.datetime.strptime(match.group(1), '%Y-%m-%dT%H:%M:%S.%f').replace(tzinfo=datetime.timezone.utc)
+            else:
+                # Without milliseconds
+                return datetime.datetime.strptime(match.group(1), '%Y-%m-%dT%H:%M:%S').replace(tzinfo=datetime.timezone.utc)
+        else:
+            if '.' in input_string:
+                # With milliseconds
+                return datetime.datetime.strptime(match.group(1), '%Y-%m-%dT%H:%M:%S.%f')
+            else:
+                # Without milliseconds
+                return datetime.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>.*?)\^{postal_code_pattern}\^{state_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": []}
+    parts = []
+    # 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/fhir_formatting.pyi

@@ -0,0 +1,13 @@
+from _typeshed import Incomplete
+
+type_regexes: Incomplete
+
+def assign_value(final_struct, key, value, valueType): ...
+def parse_iso8601_date(input_string): ...
+def parse_iso8601_datetime(input_string): ...
+def parse_iso8601_instant(input_string): ...
+def parse_iso8601_time(input_string): ...
+def parse_flexible_address(address): ...
+def caret_delimited_string_to_codeableconcept(caret_delimited_str): ...
+def caret_delimited_string_to_coding(caret_delimited_str): ...
+def string_to_quantity(quantity_str): ...

fhir_sheets/core/model/cohort_data_entity.py

@@ -0,0 +1,45 @@
+from typing import Dict, Any, List, Optional, Tuple
+
+from .common import get_value_from_keys
+
+class HeaderEntry:
+    def __init__(self, entityName, fieldName, jsonPath, valueType, valueSets):
+        self.entityName: Optional[str] = entityName
+        self.fieldName: Optional[str] = fieldName
+        self.jsonPath: Optional[str] = jsonPath
+        self.valueType: Optional[str] = valueType
+        self.valueSets: Optional[str] = valueSets
+        
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]):
+        return cls(get_value_from_keys(data, ['entityName', 'entity_name'], ''), get_value_from_keys(data, ['fieldName', 'field_name'], ''),get_value_from_keys(data, ['jsonPath', 'json_path'], ''),get_value_from_keys(data, ['valueType', "value_type"], ''),get_value_from_keys(data, ['valueSets', 'value_sets'], ''))
+        
+    def __repr__(self) -> str:
+        return (f"\nHeaderEntry(entityName='{self.entityName}', \n\tfieldName='{self.fieldName}', \n\tjsonPath='{self.jsonPath}',\n\tvalueType='{self.valueType}', "
+                f"\n\tvalueSets='{self.valueSets}')")
+    
+class PatientEntry:
+    def __init__(self, entries:Dict[Tuple[str,str],str]):
+        self.entries = entries
+       
+    @classmethod 
+    def from_dict(cls, entries:Dict[Tuple[str,str],str]):
+        return cls(entries)
+
+    def __repr__(self) -> str:
+        return (f"PatientEntry(\n\t'{self.entries}')")
+    
+class CohortData:
+    def __init__(self, headers: List[HeaderEntry], patients: List[PatientEntry]):
+        self.headers = headers
+        self.patients = patients
+        
+    @classmethod
+    def from_dict(cls, headers: List[Dict[str, Any]], patients: List[Dict[Tuple[str,str],str]]):
+        return cls([HeaderEntry.from_dict(header) for header in headers], [PatientEntry.from_dict(patient) for patient in patients])
+
+    def __repr__(self) -> str:
+        return (f"CohortData(\n\t-----\n\theaders='{self.headers}',\n\t-----\n\tpatients='{self.patients}')")
+    
+    def get_num_patients(self):
+        return len(self.patients)

fhir_sheets/core/model/common.py

@@ -0,0 +1,12 @@
+
+from typing import Any, Dict, List
+
+
+def get_value_from_keys(data: Dict[str, Any], keys: List[str], default: Any) -> Any:
+        lower_data = {k.lower(): v for k, v in data.items()}
+        """Helper function to find the first existing key and return its value."""
+        for key in keys:
+            lower_key = key.lower()
+            if lower_key in lower_data:
+                return lower_data[lower_key]
+        return default

fhir_sheets/core/model/resource_definition_entity.py

@@ -0,0 +1,30 @@
+from typing import Any, Dict, List, Optional
+
+from .common import get_value_from_keys
+
+
+class ResourceDefinition:
+    """
+    A class to represent a Resource Definition for FHIR initialization.
+    """
+    entityName_keys = ['Entity Name', 'name', 'entity_name']
+    resourceType_keys = ['ResourceType', 'resource_type', 'type']
+    profile_keys = ['Profile(s)', 'profiles', 'profile_list']
+    
+    def __init__(self, entityName: str, resourceType: str, profiles: List[str]):
+        """
+        Initializes the ResourceLink object from a dictionary.
+
+        Args:
+            data: A dictionary containing 'EntityName', 'ResourceType', and 'Profile(s)'.
+        """
+        self.entityName = entityName
+        self.resourceType = resourceType
+        self.profiles = profiles
+        
+    @classmethod
+    def from_dict(cls, data:  Dict[str, Any]):
+        return cls(get_value_from_keys(data, cls.entityName_keys, ''), get_value_from_keys(data, cls.resourceType_keys, ''), get_value_from_keys(data, cls.profile_keys, []))
+
+    def __repr__(self) -> str:
+        return f"ResourceDefinition(entityName='{self.entityName}', resourceType='{self.resourceType}', profiles={self.profiles})"

fhir_sheets/core/model/resource_link_entity.py

@@ -0,0 +1,32 @@
+from typing import Any, Dict
+
+from .common import get_value_from_keys
+
+
+class ResourceLink:
+    """
+    A class to represent a Fhir Reference between two resources.
+    """
+    originResource_keys = ['OriginResource', 'Origin Resource', 'origin_resource']
+    referencePath_keys = ['ReferencePath', 'Reference Path', 'reference_path']
+    destinationResource_keys = ['DestinationResource', 'Destination Resource', 'destination_resource']
+    def __init__(self, originResource: str, referencePath: str, destinationResource: str):
+        """
+        Initializes the ResourceLink object from a dictionary.
+
+        Args:
+            data: A dictionary containing 'OriginResource', 'ReferencePath', and 'DestinationResource'.
+        """
+        self.originResource = originResource
+        self.referencePath = referencePath
+        self.destinationResource = destinationResource
+        
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]):
+        return cls(get_value_from_keys(data, cls.originResource_keys, ''), get_value_from_keys(data, cls.referencePath_keys, ''), 
+            get_value_from_keys(data, cls.destinationResource_keys, ''))
+        
+    def __repr__(self) -> str:
+        return (f"ResourceLink(originResource='{self.originResource}', "
+                f"referencePath='{self.referencePath}', "
+                f"destinationResource='{self.destinationResource}')")

fhir_sheets/core/read_input.py

@@ -0,0 +1,102 @@
+from typing import List
+import openpyxl
+
+from .model.cohort_data_entity import CohortData, CohortData
+
+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
+    workbook = openpyxl.load_workbook(file_path)
+    resource_definition_entities = []
+    resource_link_entities = []
+    cohort_data = CohortData.from_dict([],[])
+    # 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']
+        cohort_data = process_sheet_patient_data_revised(sheet, resource_definition_entities)
+    
+    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) -> List[ResourceDefinition]:
+    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):
+        row_data = dict((h, r) for h, r in zip(headers, row) if h is not None)  # 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_definition_entities.append(ResourceDefinition.from_dict(row_data))
+        resource_definitions.append(row_data)
+    print(f"Resource Definitions\n----------{resource_definitions}")
+    return resource_definition_entities
+
+# Function to process the specific sheet with 'OriginResource', 'ReferencePath', and 'DestinationResource'
+def process_sheet_resource_links(sheet) -> List[ResourceLink]:
+    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.from_dict(row_data))
+    print(f"Resource Links\n----------{resource_links}")
+    return resource_link_entities
+
+# Function to process the "PatientData" sheet for the Revised CohortData
+def process_sheet_patient_data_revised(sheet, resource_definition_entities):
+    headers = []
+    patients = []
+    # Initialize the dictionary to store the processed data
+    # Process the Header Entries from the first 6 rows (Entity To Query, JsonPath, etc.) and the data from the rest.
+    for col in sheet.iter_cols(min_row=1, 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.entityName 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 a header entry
+        header_data = {
+            "fieldName": field_name,
+            "entityName": entity_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
+        }
+        headers.append(header_data)
+        # Create a data entry
+        values = col[6:] # The values come from the 6th row and below
+        values = tuple(item for item in values if item is not None)
+        #Expand the patient dictionary set if needed
+        if len(values) > len(patients):
+            needed_count = len(values) - len(patients)
+            patients.extend([{}] * needed_count)
+        for patient_dict, value in zip(patients, values):
+            patient_dict[(entity_name, field_name)] = value
+    print(f"Headers\n----------{headers}")
+    print(f"Patients\n----------{patients}")
+    cohort_data = CohortData.from_dict(headers=headers, patients=patients)
+    return cohort_data

fhir_sheets/core/read_input.pyi

@@ -0,0 +1,8 @@
+from .model.cohort_data_entity import CohortData as CohortData
+from .model.resource_definition_entity import ResourceDefinition as ResourceDefinition
+from .model.resource_link_entity import ResourceLink as ResourceLink
+
+def read_xlsx_and_process(file_path): ...
+def process_sheet_resource_definitions(sheet) -> list[ResourceDefinition]: ...
+def process_sheet_resource_links(sheet) -> list[ResourceLink]: ...
+def process_sheet_patient_data_revised(sheet, resource_definition_entities): ...