h-adminsim 1.0.0__py3-none-any.whl

h_adminsim/utils/fhir_utils.py

@@ -0,0 +1,190 @@
+import re
+
+from h_adminsim.utils.common_utils import (
+    iso_to_hour,
+    iso_to_date,
+    sort_schedule,
+    convert_time_list_to_merged_time,
+)
+
+
+
+def sanitize_id(s: str) -> str:
+    """
+    Sanitize a string to conform to the pattern: ^[A-Za-z0-9\-\.]{1,64}$
+
+    Args:
+        s (str): The input string to sanitize.
+
+    Returns:
+        str: A sanitized string containing only allowed characters,
+             and no longer than 64 characters.
+    """
+    cleaned = re.sub(r'[^A-Za-z0-9\-\.]', '', s)
+    return cleaned[:64]
+
+
+
+def get_individual_id(hospital: str, department_code: str, individual_name: str) -> str:
+    """
+    Make an individual ID.
+
+    Args:
+        hospital (str): A hospital name.
+        department_code (str): A department code.
+        individual_name (str): An individual name.
+    
+    Returns:
+        str: A sanitized individual ID.
+    """
+    return sanitize_id(f'{hospital}-{department_code.lower()}-{individual_name}')
+
+
+
+def get_practitionerrole_id(individual_id: str) -> str:
+    """
+    Make a practitioner role ID for an individual.
+
+    Args:
+        individual_id (str): An individual ID.
+
+    Returns:
+        str: A practitioner role ID.
+    """
+    return f'{individual_id}-role'
+
+
+
+def get_schedule_id(individual_id: str) -> str:
+    """
+    Make a schedule ID for an individual.
+
+    Args:
+        individual_id (str): An individual ID.
+
+    Returns:
+        str: A schedule ID.
+    """
+    return f'{individual_id}-schedule'
+
+
+
+def get_slot_id(individual_id: str, date: str, time_segment_index: int) -> str:
+    """
+    Make a slot ID for an individual.
+
+    Args:
+        individual_id (str): An individual ID.
+        date (str): A date in ISO format (YYYY-MM-DD).
+        time_segment_index (int): An index of start time segment.
+
+    Returns:
+        str: A slot ID.
+    """
+    return f"{individual_id}-{date.replace('-', '')}-slot{time_segment_index}"
+
+
+
+def get_appointment_id(individual_id: str, date: str, start_time_segment_index: int, end_time_segment_index: int) -> str:
+    """
+    Make an appointment ID for an individual.
+
+    Args:
+        individual_id (str): An individual ID.
+        date (str): A date in ISO format (YYYY-MM-DD).
+        start_time_segment_index (int): An index of start time segment.
+        end_time_segment_index (int): An index of end time segment.
+
+    Returns:
+        str: An appointment ID.
+    """
+    return f"{individual_id}-{date.replace('-', '')}-appn{start_time_segment_index}-{end_time_segment_index}"
+
+
+
+def get_all_doctor_info(practitioners: list[dict],
+                        practitioner_roles: list[dict],
+                        schedules: list[dict],
+                        slots: list[dict],
+                        appointments: list[dict],
+                        **kwargs) -> dict:
+    """
+    Make a current state of doctoral information based on the FHIR server.
+
+    Args:
+        practitioners (list[dict]): Practitioner resources currently used in the hospital environment of the simulation.
+        practitioner_roles (list[dict]): PractitionerRole resources currently used in the hospital environment of the simulation.
+        schedules (list[dict]): Schedule resources currently used in the hospital environment of the simulation.
+        slots (list[dict]): Slot resources currently used in the hospital environment of the simulation._
+        appointments (list[dict]): Appointment resources currently used in the hospital environment of the simulation.
+
+    Returns:
+        dict: Current state of doctoral information. 
+    """
+    # Prepare several pre-required data
+    doctor_information = dict()
+    practitioner_ref_to_role = dict()
+    practitioner_ref_to_schedules = dict()
+    practitioner_ref_to_name = {
+        f"Practitioner/{practitioner['resource']['id']}": \
+            f"{practitioner['resource']['name'][0]['prefix'][0]} {practitioner['resource']['name'][0]['given'][0]} {practitioner['resource']['name'][0]['family']}" \
+                for practitioner in practitioners
+    }
+    for practitioner_role in practitioner_roles:
+        attributes = {attr['text']: attr['coding'][0]['display'] for attr in practitioner_role['resource']['characteristic']}
+        practitioner_ref_to_role[practitioner_role['resource']['practitioner']['reference']] = {
+            'department': practitioner_role['resource']['specialty'][0]['text'],
+            'specialty': {
+                'name': practitioner_role['resource']['specialty'][0]['coding'][0]['display'],
+                'code': practitioner_role['resource']['specialty'][0]['coding'][0]['code']
+            },
+            'capacity_per_hour': int(attributes['capacity_per_hour']),
+            'capacity': int(attributes['capacity']),
+        }
+    schedule_ref_to_practioner_ref = {
+        f"Schedule/{schedule['resource']['id']}": schedule['resource']['actor'][0]['reference'] for schedule in schedules
+    }
+
+    # Append fixed schedules of a doctor
+    for slot in slots:
+        resource = slot['resource']
+        practitioner_ref = schedule_ref_to_practioner_ref[slot['resource']['schedule']['reference']]
+        date = iso_to_date(resource['start'])
+        practitioner_dict = practitioner_ref_to_schedules.setdefault(practitioner_ref, {})
+        practitioner_dict.setdefault(date, [])
+        if not resource['status'] == 'free':
+            practitioner_dict[date].append([iso_to_hour(resource['start']), iso_to_hour(resource['end'])])
+
+    # Merge fixed schedule times
+    if all(k in kwargs for k in ['start', 'end', 'interval']):
+        for fixed_schedules in practitioner_ref_to_schedules.values():
+            for date, time_list in fixed_schedules.items():
+                fixed_schedules[date] = convert_time_list_to_merged_time(time_list=sort_schedule(time_list), **kwargs)
+
+    # Append patient appointments of a doctor
+    for appointment in appointments:
+        resource = appointment['resource']
+        for participant in resource['participant']:
+            participant_ref = participant['actor']['reference']
+            date = iso_to_date(resource['start'])
+            practitioner_dict = practitioner_ref_to_schedules.setdefault(participant_ref, {})
+            if participant_ref in practitioner_ref_to_name:
+                practitioner_dict[date].append([iso_to_hour(resource['start']), iso_to_hour(resource['end'])])
+                break
+        
+    # Build the doctor information from FHIR
+    for practitioner in practitioners:
+        resource = practitioner['resource']
+        ref = f"Practitioner/{resource['id']}"
+        doctor_information[practitioner_ref_to_name[ref]] = {
+            'department': practitioner_ref_to_role[ref]['department'],
+            'specialty': practitioner_ref_to_role[ref]['specialty'],
+            'schedule': sort_schedule(practitioner_ref_to_schedules.get(ref, [])),
+            'capacity_per_hour': practitioner_ref_to_role[ref]['capacity_per_hour'],
+            'capacity': practitioner_ref_to_role[ref]['capacity'],
+            'gender': resource['gender'],
+            'telecom': resource['telecom'],
+            'birthDate': resource['birthDate']
+        }
+
+    return doctor_information

h_adminsim/utils/filesys_utils.py

@@ -0,0 +1,135 @@
+import os
+import json
+import orjson
+from typing import Any
+from pathlib import Path
+
+from h_adminsim.utils import log
+
+
+
+def txt_load(path: str) -> str:
+    """
+    Load and return the content of a text file.
+
+    Args:
+        path (str): Path to the text file.
+
+    Returns:
+        str: The full content of the text file as a string.
+    """
+    with open(path, 'r') as f:
+        content = f.read()
+    return content    
+
+
+
+def json_load(path: str) -> Any:
+    """
+    Load and parse a JSON file.
+
+    Args:
+        path (str): Path to the JSON file.
+
+    Returns:
+        Any: The parsed Python object (usually a dict or list) from the JSON file.
+    """
+    with open(path, 'r') as f:
+        return json.load(f)
+
+
+
+def json_save(path: str, data: dict):
+    """
+    Save json file.
+
+    Args:
+        path (str): Path to the json file.
+        data (dict): Data to save.
+    """
+    with open(path, 'w') as f:
+        json.dump(data, f, indent=4, ensure_ascii=False)
+
+
+
+def json_save_fast(path: str, data: dict):
+    """
+    Save json file more faster.
+
+    Args:
+        path (str): Path to the json file.
+        data (dict): Data to save.
+    """
+    with open(path, 'wb') as f:
+        f.write(orjson.dumps(data, option=orjson.OPT_INDENT_2))
+
+
+
+def yaml_save(file: str='data.yaml', data: Any = None):
+    """
+    Save data to an YAML file.
+
+    Args:
+        file (str, optional): File name. Default is 'data.yaml'.
+        data (Any, optional): Data to save in YAML format.
+    """
+    save_path = Path(file)
+    log(data.dumps())
+    with open(save_path, "w") as f:
+        f.write(data.dumps(modified_color=None, quote_str=True))
+        log(f"Config is saved at {save_path}")
+
+
+
+def get_files(path: str, ext: str = None) -> list[str]:
+    """
+    Get all files in a directory with a specific extension.
+
+    Args:
+        path (str): Folder path to search for files.
+        ext (str, optional): Extension that you want to filter. Defaults to None.
+
+    Raises:
+        ValueError: If file does not exist.
+
+    Returns:
+        list[str]: List of file paths that match the given extension.
+    """
+    if not os.path.isdir(path):
+        raise ValueError(f"Path {path} is not a directory.")
+    
+    files = []
+    for root, _, filenames in os.walk(path):
+        for filename in filenames:
+            if ext is None or filename.endswith(ext):
+                files.append(os.path.join(root, filename))
+    
+    return files
+
+
+
+def make_project_dir(config) -> Path:
+    """
+    Make project folder.
+
+    Args:
+        config: yaml config.
+
+    Returns:
+        (path): project folder path.
+    """
+    prefix = log('Make project folder')
+    project = config.project
+    name = config.data_name
+
+    save_dir = os.path.join(project, name)
+    if os.path.exists(save_dir):
+        log(f'{prefix}: Project {save_dir} already exists. New folder will be created.')
+        name = name + str(len(os.listdir(project))+1)
+        config.data_name = name
+        save_dir = os.path.join(project, name)
+    
+    os.makedirs(project, exist_ok=True)
+    os.makedirs(save_dir)
+    
+    return Path(save_dir)

h_adminsim/utils/image_preprocess_utils.py

@@ -0,0 +1,188 @@
+import io
+import os
+import math
+import base64
+from PIL import Image
+from collections import Counter
+from typing import Tuple, Union
+import matplotlib.pyplot as plt
+
+
+
+def encode_image(image_path: str, encode_base64: bool = True) -> Union[str, bytes]:
+    """
+    Read an image file and return its binary content, optionally encoded in base64.
+
+    Args:
+        image_path (str): Path to the image file.
+        encode_base64 (bool, optional): If True, the image is returned as a base64-encoded string.
+                                        If False, the raw binary content is returned. Defaults to True.
+
+    Returns:
+        Union[str, bytes]: The base64-encoded string or raw binary content of the image,
+                           depending on the value of `encode_base64`.
+    """
+    with open(image_path, "rb") as image_file:
+        if encode_base64:
+            return base64.b64encode(image_file.read()).decode("utf-8")
+        return image_file.read()
+
+
+
+def encode_resize_image(image_path: str, max_size: Tuple[int], encode_base64: bool = True) -> Union[str, bytes]:
+    """
+    Resize an image to fit within the specified maximum dimensions and return its content,
+    optionally encoded in base64.
+
+    If the original image is smaller than the specified max size, it will be returned without resizing.
+
+    Args:
+        image_path (str): Path to the input image file.
+        max_size (Tuple[int]): Maximum allowed size as (width, height). The image will be resized
+                               proportionally to fit within this box while preserving aspect ratio.
+        encode_base64 (bool, optional): If True, the image content is returned as a base64-encoded string.
+                                        If False, raw binary data is returned. Defaults to True.
+
+    Returns:
+        Union[str, bytes]: The resized image as a base64-encoded string or raw binary data,
+                           depending on the value of `encode_base64`.
+    """
+    with Image.open(image_path) as img:
+        original_width, original_height = img.size
+        
+        # Resize the image
+        width_ratio = max_size[0] / original_width
+        height_ratio = max_size[1] / original_height
+        min_ratio = min(width_ratio, height_ratio)
+        
+        if min_ratio >= 1:
+            return encode_image(image_path, encode_base64)
+
+        new_width = int(original_width * min_ratio)
+        new_height = int(original_height * min_ratio)
+
+        img = img.resize((new_width, new_height))
+
+        # Save image to memeory
+        img_buffer = io.BytesIO()
+        img.save(img_buffer, format="JPEG")
+        img_buffer.seek(0)
+
+        if encode_base64:
+            return base64.b64encode(img_buffer.read()).decode("utf-8")
+        return img_buffer.read()
+    
+
+
+def get_image_extension(path: str) -> str:
+    """
+    Extract and normalize the image file extension from the given file path.
+
+    Args:
+        path (str): Path to the image file.
+
+    Raises:
+        ValueError: If the file extension is not a supported image format.
+
+    Returns:
+        str: Normalized image format string. Returns "png" for PNG files,
+             and "jpeg" for JPG or JPEG files. 
+    """
+    ext = os.path.splitext(path)
+    if ext == "png":
+        return ext
+    elif ext in ["jpeg", "jpg"]:
+        return "jpeg"
+    else:
+        raise ValueError(f"Unsupported image format: {ext}")
+
+
+
+def autopct_format(values: list[int], threshold: float = 5.0):
+    """
+    Returns a formatting function for pie chart percentages and counts.
+
+    Args:
+        values (list[int]): List of values corresponding to each pie chart slice.
+        threshold (float): Minimum percentage value required to display the label. Slices with 
+                           percentages below this threshold will not show any text.
+
+    Returns:
+        function: A function that takes a percentage (float) and returns a formatted string
+                  showing both the percentage and the corresponding count, e.g., '42.0%\n(21)'.
+    """
+    def my_autopct(pct):
+        total = sum(values)
+        count = int(round(pct * total / 100.0))
+        return f'{pct:.1f}%\n({count})' if pct > threshold else ''
+    return my_autopct
+
+
+
+def draw_fail_donut_subplots(fail_data_dict: dict, save_path: str):
+    """
+    Draws donut-style pie chart subplots showing the failure type distribution for each task.
+
+    Args:
+        fail_data_dict (dict): A dictionary where keys are task names and values are lists of failure types (e.g., error codes).
+        save_path (str): File path where the final figure will be saved as a PNG.
+    """
+    keys = list(fail_data_dict.keys())
+    num_plots = len(keys)
+
+    if num_plots == 0:
+        return
+
+    # Calculate subplot layout (maximum of 4 columns)
+    ncols = min(4, num_plots)
+    nrows = math.ceil(num_plots / ncols)
+
+    fig, axes = plt.subplots(nrows, ncols, figsize=(5 * ncols, 7 * nrows))
+    axes = axes.flatten() if num_plots > 1 else [axes]
+    cmap = plt.get_cmap('tab10')
+    
+    for idx, key in enumerate(keys):
+        failed_cases = fail_data_dict[key]
+        fail_summary = Counter(failed_cases)
+        labels = list(fail_summary.keys())
+        sizes = list(fail_summary.values())
+        sorted_items = sorted(zip(labels, sizes), key=lambda x: x[1], reverse=True)
+        labels, sizes = zip(*sorted_items)  
+        total = sum(sizes)
+        percentages = [s / total * 100 for s in sizes]
+        colors = cmap.colors[:len(labels)]
+
+        ax = axes[idx]
+        pct_str = autopct_format(sizes, 4.0)
+        
+        wedges, texts, autotexts = ax.pie(
+            sizes,
+            labels=None,
+            autopct=pct_str,
+            pctdistance=0.7,
+            startangle=90,
+            counterclock=False,
+            colors=colors,
+            wedgeprops=dict(width=0.7)
+        )
+
+        legend_labels = [f"{label} ({pct:.1f}%, {size})" if pct < 4.0 else label for label, size, pct in zip(labels, sizes, percentages)]
+        ax.legend(
+            wedges,
+            legend_labels,
+            title="Failure Types",
+            loc="lower center",
+            bbox_to_anchor=(0.5, -0.3),
+            ncol=2,
+            fontsize=9
+        )
+        ax.set_title(f'"{key}"', fontsize=12, pad=10)
+        ax.axis('equal')
+
+    # Clear remaining empty subplots
+    for idx in range(len(keys), len(axes)):
+        axes[idx].axis('off')
+    
+    fig.suptitle('Failure Type Distribution by Task', fontsize=16)
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300)