h-adminsim 1.0.0__py3-none-any.whl

h_adminsim/task/fhir_manager.py

@@ -0,0 +1,222 @@
+import requests
+from typing import Optional
+from urllib.parse import urlencode
+
+from h_adminsim.utils import log
+
+
+
+class FHIRManager:
+    def __init__(self, fhir_url):
+        self.fhir_url = fhir_url
+        
+    
+    def __logging(self, response: requests.Response, verbose=True) -> Optional[requests.Response]:
+        """
+        Log the response status code and content.
+
+        Args:
+            response (requests.Response): The HTTP response object.
+            verbose (bool, optional): If True, log details. Defaults to True.
+
+        Returns:
+            Optional[requests.Response]: The response object if JSON parsing is successful, else None.
+        """
+        if  200 <= response.status_code < 300:
+            if verbose:
+                log(f'Status code: {response.status_code}', color=True)
+        else:
+            if verbose:
+                log(f'Status code: {response.status_code}', level='error')
+        
+        try:
+            response_json = response.json()
+            if verbose:
+                log(f'Response JSON: {response_json}')      
+        except ValueError:
+            if verbose:
+                log(f'Response Text: {response.text}', level='error')
+            response = None
+        return response
+
+
+    def create(self, 
+               resource_type: str, 
+               resource_data: dict, 
+               headers: Optional[dict] = None, 
+               verbose: bool = True) -> Optional[requests.Response]:
+        """
+        Create a FHIR resource of the specified type.
+
+        Args:
+            resource_type (str): FHIR resource type (e.g., "Patient", "PractitionerRole").
+            resource_data (dict): FHIR resource data as a dictionary.
+            headers (Optional[dict], optional): HTTP headers to use. Defaults to None.
+            verbose (bool, optional): If True, log details. Defaults to True.
+
+        Returns:
+            Optional[requests.Response]: The HTTP response object if JSON parsing is successful, else None.
+        """
+        _id = resource_data.get('id')
+        fhir_url = f'{self.fhir_url}/{resource_type}/{_id}'
+        response = requests.put(
+            fhir_url,
+            headers={'Content-Type': 'application/fhir+json'} if headers is None else headers,
+            json=resource_data,
+        )
+
+        # Log and return the response
+        return self.__logging(response, verbose)
+    
+    
+    def read(self, 
+             resource_type: str, 
+             id: str, 
+             headers: Optional[dict] = None, 
+             verbose: bool = True) -> Optional[requests.Response]:
+        """
+        Read a FHIR resource of the specified type and ID.
+
+        Args:
+            resource_type (str): FHIR resource type (e.g., "Patient", "PractitionerRole").
+            id (str): The ID of the FHIR resource to read.
+            headers (Optional[dict], optional): HTTP headers to use. Defaults to None.
+            verbose (bool, optional): If True, log details. Defaults to True.
+
+        Returns:
+            Optional[requests.Response]: The HTTP response object if JSON parsing is successful, else None.
+        """
+        fhir_url = f'{self.fhir_url}/{resource_type}/{id}'
+        response = requests.get(
+            fhir_url,
+            headers={'Accept': 'application/fhir+json'} if headers is None else headers,
+        )
+
+        # Log and return the response
+        return self.__logging(response, verbose)
+    
+
+    def update(self, 
+               resource_type: str, 
+               id: str, 
+               resource_data: dict, 
+               headers: Optional[dict] = None,
+               verbose: bool = True) -> Optional[requests.Response]:
+        """
+        Update a FHIR resource of the specified type and ID.
+
+        Args:
+            resource_type (str): FHIR resource type (e.g., "Patient", "PractitionerRole").
+            id (str): The ID of the FHIR resource to update.
+            resource_data (dict): FHIR resource data as a dictionary.
+            headers (Optional[dict], optional): HTTP headers to use. Defaults to None.
+            verbose (bool, optional): If True, log details. Defaults to True.
+
+        Returns:
+            Optional[requests.Response]: _description_
+        """
+        fhir_url = f'{self.fhir_url}/{resource_type}/{id}'
+        response = requests.put(
+            fhir_url,
+            headers={'Content-Type': 'application/fhir+json'} if headers is None else headers,
+            json=resource_data,
+        )
+
+        # Log and return the response
+        return self.__logging(response, verbose)
+
+
+    def delete(self, resource_type: str, id: str, verbose=True):
+        fhir_url = f'{self.fhir_url}/{resource_type}/{id}'
+        response = requests.delete(
+            fhir_url
+        )
+
+        # Log and return the response
+        return self.__logging(response, verbose)
+
+
+    def read_all(self,
+                 resource_type: str,
+                 headers: Optional[dict] = None,
+                 count: int = 100,
+                 verbose: bool = True,
+                 params: Optional[dict] = None) -> list[dict]:
+        """
+        Read all resources of a given resource type using FHIR search with optional filtering.
+
+        Args:
+            resource_type (str): FHIR resource type (e.g., "PractitionerRole").
+            headers (dict, optional): HTTP headers to use.
+            count (int): Number of resources to fetch per page (default: 100).
+            verbose (bool): If True, log each response. Defaults to True.
+            params (dict, optional): FHIR search parameters (e.g., {"specialty": "IMALL-2"}).
+
+        Returns:
+            list[dict]: List of bundle entry dicts.
+        """
+        all_entries = []
+        headers = {'Accept': 'application/fhir+json'} if headers is None else headers
+
+        # Build first page URL with params
+        q = {'_count': count}
+        if params:
+            q.update({k: v for k, v in params.items() if v is not None})
+        url = f"{self.fhir_url}/{resource_type}?{urlencode(q, doseq=True)}"
+
+        while url:
+            response = requests.get(url, headers=headers)
+            self.__logging(response, verbose)
+            try:
+                bundle = response.json()
+            except Exception:
+                break
+
+            if bundle.get('resourceType') != 'Bundle' or 'entry' not in bundle:
+                break
+
+            all_entries.extend(bundle['entry'])
+
+            # Check for next link (pagination)
+            next_link = next(
+                (link.get('url') for link in bundle.get('link', []) if link.get('relation') == 'next'),
+                None
+            )
+            url = next_link  # Continue if next page exists, else break
+
+        return all_entries
+    
+
+    def delete_all(self, entry: list[dict], verbose: bool = True):
+        """
+        Delete all FHIR resources from a given list of resource entries.
+
+        Args:
+            entry (list[dict]): List of FHIR Bundle entries, typically from the `read_all()` method.
+                                Each entry should contain a 'resource' dict with 'resourceType' and 'id'.
+            verbose (bool): If True, log each deletion response. Defaults to True.
+        """
+        error_ids = list()
+
+        for resource in entry:
+            resource_type = resource.get('resource').get('resourceType')
+            id = resource.get('resource').get('id')
+            response = self.delete(resource_type, id, verbose)
+
+            if not 200 <= response.status_code < 300:
+                error_ids.append(id)
+
+        if error_ids:
+            log(f'Error(s) occurs during delete resources: {error_ids}', 'warning')
+        else:
+            log('Deletion successfully completed', color=True)
+
+
+        
+
+# PostgreSQL
+# docker exec -it jmlee_fhir_db psql -U admin -d hapi
+# SELECT * FROM hfj_resource WHERE res_type = 'Patient' LIMIT 1;
+# SELECT * FROM HFJ_RES_VER WHERE RES_ID = 925754;
+
+    

h_adminsim/task/schedule_assign.py

@@ -0,0 +1,151 @@
+import random
+from typing import Tuple, Optional
+
+from h_adminsim.utils.common_utils import (
+    convert_segment_to_time,
+    convert_time_to_segment, 
+    group_consecutive_segments,
+)
+
+
+
+class ScheduleAssigner:
+    def __init__(self, start: float, end: float, interval: float):
+        """
+        Initialize a ScheduleAssigner for generating random schedules or appointments.
+
+        This class divides a given time range into fixed-size segments and provides methods
+        to assign schedules or appointments by selecting and grouping these segments.
+
+        Args:
+            start (float): Start time in hours (e.g., 9.0 for 09:00).
+            end (float): End time in hours (e.g., 18.0 for 18:00).
+            interval (float): Time interval in hours for each segment (e.g., 0.5 for 30 minutes).
+        """
+        self.start = start
+        self.end = end
+        self.interval = interval
+        self.segments = convert_time_to_segment(self.start, self.end, self.interval)
+
+
+    def schedule_segment_assign(self,
+                                p: float,
+                                segments: Optional[list[int]] = None) -> list[list[int]]:
+        """
+        Randomly assign a proportion of schedule time segments into grouped consecutive blocks.
+
+        This method selects a random subset of segments, where the number of segments is 
+        determined by the proportion `p` (e.g., 0.5 means 50% of all segments).
+        The selected segments are then grouped into lists of consecutive segment indices.
+
+        Args:
+            p (float): Proportion of total segments to assign, between 0 and 1.
+            segments (Optional[list[int]], optional): Specific segments. Defaults to None.
+
+        Returns:
+            list[list[int]]: A list of groups, where each group is a list of consecutive segment indices.
+                            For example, [[0, 1], [3, 4, 5], [7]].
+
+        Example:
+            If segments = [0, 1, 2, ..., 11] and p = 0.5,
+            this function might return something like:
+                [[0, 1], [4], [6, 7, 8]]
+
+        Notes:
+            - The segment indices are selected randomly each time the function is called.
+            - Groups are always composed of consecutive indices from the selected subset.
+        """
+        segments = self.segments if segments == None else segments
+        segment_n = round(len(segments) * p)
+
+        if segment_n > 0:
+            # Select random segments
+            chosen_segments = random.sample(segments, segment_n)
+            chosen_segments.sort()
+
+            # Grouping consecutive segments
+            grouped = group_consecutive_segments(chosen_segments)
+            return grouped
+        return []
+    
+
+    def appointment_segment_assign(self,
+                                   p: float,
+                                   min_chunk_size: int,
+                                   max_chunk_size: int,
+                                   segments: Optional[list[int]] = None) -> list[list[int]]:
+        """
+        Randomly assign appointment time segments from the remaining (unassigned) segments.
+
+        Args:
+            p (float): Proportion of remaining segments to sample and assign.
+            min_chunk_size (int): The minimum time segment size for each appointment.
+            max_chunk_size (int): The maximum time segment size for each appointment.
+            segments (Optional[list[int]], optional): Specific segments. Defaults to None.
+
+        Returns:
+            list[list[int]]: Newly assigned segments from the remaining pool, grouped consecutively.
+        """
+        segments = self.segments if segments == None else segments
+        avg_chunk_size = (min_chunk_size + max_chunk_size) / 2
+        segment_n = int(len(segments) * p // avg_chunk_size)
+
+        if segment_n > 0:
+            chosen = []
+            used = set()
+            max_index = max(segments)
+            random.shuffle(segments)
+            
+            for s in segments:
+                max_possible_size = min(max_chunk_size, max_index - s + 1)
+                if max_possible_size < min_chunk_size:
+                    continue
+
+                chunk_size = random.randint(min_chunk_size, max_chunk_size)
+                trip = set(range(s, s + chunk_size))
+
+                if used.isdisjoint(trip):
+                    chosen.append((s, chunk_size))
+                    used |= trip
+                    if len(chosen) == segment_n:
+                        break
+
+            return [list(range(start, start + size)) for start, size in sorted(chosen)]
+        return []
+    
+
+    def __call__(self,
+                 p: float,
+                 is_appointment: bool = False,
+                 segments: Optional[list[list[int]]] = None,
+                 **kwargs) -> Tuple[list[list[int]], list[list[float]]]:
+        """
+        Generate grouped time ranges by randomly selecting and grouping a proportion of time segments.
+
+        This method allows the ScheduleAssigner instance to be called directly with a proportion `p`.
+        It selects a subset of time segments based on `p`, groups them into consecutive segment blocks,
+        and converts each group of segment indices into their corresponding time values.
+
+        Args:
+            p (float): Proportion of total segments to select, between 0 and 1.
+            is_appointment (bool, optional): Whether the generated schedules are for appointments. Defaults to False.
+            segments (Optional[list[list[int]]], optional): Specific segemnts. Defaults to None.
+
+        Returns:
+            list[list[float]]: A list of grouped time segments. Each group is a list of time segemnt values.
+                            For example: [[2, 3], [5, 6, 7]].
+            list[list[float]]: A list of grouped time ranges. Each group is a list of time values (in hours),
+                            corresponding to consecutive time segments.
+                            For example: [[0.0, 0.5], [2.0, 3.0]].
+
+        Example:
+            >>> assigner = ScheduleAssigner(0, 12, 0.5)
+            >>> assigner(0.25)
+            [[1.0, 1.5], [4.5], [6.0, 6.5]]
+        """
+        time_segments = self.appointment_segment_assign(p, segments=segments, **kwargs) \
+            if is_appointment else self.schedule_segment_assign(p, segments)
+
+        if len(time_segments):
+            return time_segments, [list(convert_segment_to_time(self.start, self.end, self.interval, segments)) for segments in  time_segments]
+        return [], []

h_adminsim/tools/__init__.py

@@ -0,0 +1,5 @@
+from .scheduling_rule import *
+from .data_converter import DataConverter
+from .agent_data_builder import AgentDataBuilder
+from .data_synthesizer import DataSynthesizer
+from .evaluator import Evaluator

h_adminsim/tools/agent_data_builder.py

@@ -0,0 +1,124 @@
+import os
+from tqdm import tqdm
+from typing import Optional
+from decimal import getcontext
+from importlib import resources
+
+from h_adminsim.utils.fhir_utils import *
+from h_adminsim.utils.random_utils import generate_random_symptom
+from h_adminsim.utils.filesys_utils import json_load, json_save_fast, get_files
+
+
+
+class AgentDataBuilder:
+    def __init__(self, config):
+        # Initialize configuration
+        data_dir = os.path.join(config.project, config.data_name, 'data')
+        self.data_files = get_files(data_dir, ext='json')
+        getcontext().prec = 10
+
+
+    @staticmethod
+    def build(data: dict, 
+              save_path: Optional[str] = None, 
+              symptom_file_path: Optional[str] = None) -> dict:
+        """
+        Build agent test data from a single hospital data entry.
+
+        Args:
+            data (dict): Dictionary containing metadata, departments, doctors, and patients.
+            save_path (Optional[str], optional): If provided, the generated agent data will be saved to this path.
+            symptom_file_path (str, optional): Path to the JSON file containing symptoms per department. Defaults to None.
+
+        Returns:
+            dict: A dictionary with the following keys:
+                - 'metadata': Original metadata from input.
+                - 'department': Department-level information.
+                - 'doctor': Doctor-level information.
+                - 'agent_data': List of tuples. Each tuple consists of:
+                    - Ground-truth scheduling information.
+                    - Agent input (symptom and constraints).
+        """
+        if symptom_file_path == None:
+            symptom_file_path = str(resources.files("h_adminsim.assets.departments").joinpath("symptom.json"))
+
+        agent_data = {'metadata': data['metadata'], 'department': data['department'], 'doctor': data['doctor'], 'agent_data': []}
+        
+        for patient, patient_values in data['patient'].items():
+            doctor, department, date = patient_values['attending_physician'], patient_values['department'], patient_values['date']
+            gender, telecom, birth_date, identifier, address = \
+                patient_values['gender'], patient_values['telecom'], patient_values['birthDate'], patient_values['identifier'], patient_values['address']
+            preference, symptom_level = patient_values['preference'], patient_values['symptom_level']
+            disease = generate_random_symptom(
+                department=department,
+                symptom_file_path=symptom_file_path, 
+                ensure_unique_department='doctor' in patient_values['preference']
+            )
+            gt_department = disease['department'] if isinstance(disease, dict) else [department]
+            gt = {
+                'patient': patient,
+                'gender': gender,
+                'telecom': telecom,
+                'birthDate': birth_date,
+                'identifier': identifier,
+                'address': address,
+                'department': gt_department,
+                'attending_physician': doctor,
+                'valid_from': date if 'date' in preference else 'N/A',
+                'preference': preference,
+                'symptom_level': symptom_level,
+            }
+            agent = {
+                'patient': patient,
+                'gender': gender,
+                'telecom': telecom,
+                'birthDate': birth_date,
+                'identifier': identifier,
+                'address': address,
+                'constraint': {
+                    'preference': preference,
+                    'attending_physician': doctor,
+                    'valid_from': date if 'date' in preference else 'N/A',
+                    'symptom_level': symptom_level,
+                    'symptom': disease,
+                }
+            }
+            agent_data['agent_data'].append((gt, agent))
+        
+        if save_path:
+            json_save_fast(
+                save_path,
+                agent_data
+            )
+        
+        return agent_data
+            
+
+    def __call__(self,
+                 output_dir: Optional[str] = None, 
+                 symptom_file_path: Optional[str] = None) -> list[dict]:
+        """
+        Generate agent test datasets for all input data files.
+
+        Args:
+            output_dir (Optional[str], optional): Directory to save the generated agent data files.
+                                                  If not provided, files are not saved.
+            symptom_file_path (Optional[str], optional): Path to the symptom file used during agent construction. Defaults to None.
+
+        Returns:
+            list[dict]: A list of agent test data dictionaries, one for each processed input file.
+        """
+        if symptom_file_path == None:
+            symptom_file_path = str(resources.files("h_adminsim.assets.departments").joinpath("symptom.json"))
+
+        os.makedirs(output_dir, exist_ok=True)
+        all_agent_data = list()
+        
+        for data_file in tqdm(self.data_files, desc='Generating data for agent simulation..'):
+            data = json_load(data_file)
+            basename, ext = os.path.splitext(os.path.basename(data_file))
+            agent_data = AgentDataBuilder.build(data, os.path.join(output_dir, f"{basename}_agent{ext}"), symptom_file_path)
+            all_agent_data.append(agent_data)
+        
+        return all_agent_data
+