fhir-pyrate 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

fhir_pyrate/__init__.py

@@ -24,7 +24,7 @@ DicomDownloader, _ = fhir_pyrate.util.imports.optional_import(
 
 __all__ = [
     "Ahoy",
+    "DicomDownloader",
     "Miner",
     "Pirate",
-    "DicomDownloader",
 ]

fhir_pyrate/ahoy.py

@@ -40,15 +40,15 @@ class Ahoy:
 
     def __init__(
         self,
-        auth_url: str = None,
+        auth_url: Optional[str] = None,
         auth_type: Optional[str] = "token",
-        refresh_url: str = None,
-        username: str = None,
+        refresh_url: Optional[str] = None,
+        username: Optional[str] = None,
         auth_method: Optional[str] = "password",
-        token: str = None,
+        token: Optional[str] = None,
         max_login_attempts: int = 5,
-        token_refresh_delta: Union[int, timedelta] = None,
-        session: requests.Session = None,
+        token_refresh_delta: Optional[Union[int, timedelta]] = None,
+        session: Optional[requests.Session] = None,
     ) -> None:
         self.auth_type = auth_type
         self.auth_method = auth_method
@@ -82,7 +82,7 @@ class Ahoy:
         self.close()
 
     def change_environment_variable_name(
-        self, user_env: str = None, pass_env: str = None
+        self, user_env: Optional[str] = None, pass_env: Optional[str] = None
     ) -> None:
         """
         Change the name of the variables used to retrieve username and password.

fhir_pyrate/dicom_downloader.py

@@ -14,7 +14,18 @@ import warnings
 from contextlib import contextmanager
 from functools import partial
 from types import TracebackType
-from typing import Dict, Generator, List, Optional, TextIO, Tuple, Type, Union
+from typing import (
+    ClassVar,
+    Dict,
+    FrozenSet,
+    Generator,
+    List,
+    Optional,
+    TextIO,
+    Tuple,
+    Type,
+    Union,
+)
 
 import pandas as pd
 import pydicom
@@ -67,7 +78,7 @@ def fileno(file_or_fd: TextIO) -> Optional[int]:
 @contextmanager
 def stdout_redirected(
     to: Union[str, TextIO] = os.devnull, stdout: Optional[TextIO] = None
-) -> Generator:
+) -> Generator[Optional[TextIO], None, None]:
     if platform.system() == "Windows":
         yield None
         return
@@ -136,23 +147,25 @@ class DicomDownloader:
     :param num_processes: The number of processes to run for downloading
     """
 
-    ACCEPTED_FORMATS = {
-        ".dcm",
-        ".nia",
-        ".nii",
-        ".nii.gz",
-        ".hdr",
-        ".img",
-        ".img.gz",
-        ".tif",
-        ".TIF",
-        ".tiff",
-        ".TIFF",
-        ".mha",
-        ".mhd",
-        ".nrrd",
-        ".nhdr",
-    }
+    ACCEPTED_FORMATS: ClassVar[FrozenSet[str]] = frozenset(
+        {
+            ".dcm",
+            ".nia",
+            ".nii",
+            ".nii.gz",
+            ".hdr",
+            ".img",
+            ".img.gz",
+            ".tif",
+            ".TIF",
+            ".tiff",
+            ".TIFF",
+            ".mha",
+            ".mhd",
+            ".nrrd",
+            ".nhdr",
+        }
+    )
 
     def __init__(
         self,
@@ -239,7 +252,7 @@ class DicomDownloader:
     @staticmethod
     def get_download_id(
         study_uid: str,
-        series_uid: str = None,
+        series_uid: Optional[str] = None,
         always_download_in_study_folder: bool = False,
     ) -> str:
         """
@@ -259,7 +272,7 @@ class DicomDownloader:
 
     def get_download_path(self, download_id: str) -> pathlib.Path:
         """
-        Builds the folder hierarchy where the data will be stored. The hierarchy depends on the
+        Build the folder hierarchy where the data will be stored. The hierarchy depends on the
         `hierarchical_storage` parameter. Given a download ID
         263a1dad02916f5eca3c4eec51dc9d281735b47b8eb8bc2343c56e6ccd and `hierarchical_storage` = 2,
         the data will be stored in 26/3a/1dad02916f5eca3c4eec51dc9d281735b47b8eb8bc2343c56e6ccd.
@@ -277,13 +290,13 @@ class DicomDownloader:
     def download_data(
         self,
         study_uid: str,
-        series_uid: str = None,
+        series_uid: Optional[str] = None,
         output_dir: Union[str, pathlib.Path] = "out",
         save_metadata: bool = True,
         existing_ids: Optional[List[str]] = None,
     ) -> Tuple[List[Dict[str, str]], List[Dict[str, str]]]:
         """
-        Downloads the data related to the StudyInstanceUID and SeriesInstanceUID (if given,
+        Download the data related to the StudyInstanceUID and SeriesInstanceUID (if given,
         otherwise the entire study will be downloaded).
 
         :param study_uid: The StudyInstanceUID
@@ -333,7 +346,7 @@ class DicomDownloader:
             base_dict[self.series_instance_uid_field] = series_uid
 
         # Init the readers/writers
-        series_reader = sitk.ImageSeriesReader()  # type: ignore
+        series_reader = sitk.ImageSeriesReader()
         with tempfile.TemporaryDirectory() as tmp_dir:
             # Create the download dir
             current_tmp_dir = pathlib.Path(tmp_dir)
@@ -361,11 +374,11 @@ class DicomDownloader:
             progress_bar.close()
 
             # Get Series ID names from folder
-            series_uids = sitk.ImageSeriesReader.GetGDCMSeriesIDs(str(current_tmp_dir))  # type: ignore
+            series_uids = sitk.ImageSeriesReader.GetGDCMSeriesIDs(str(current_tmp_dir))
             logger.info(f"Study ID has {len(series_uids)} series.")
             for series in series_uids:
                 # Get the DICOMs corresponding to the series
-                files = series_reader.GetGDCMSeriesFileNames(  # type: ignore
+                files = series_reader.GetGDCMSeriesFileNames(
                     str(current_tmp_dir), series
                 )
                 current_dict = base_dict.copy()
@@ -374,11 +387,12 @@ class DicomDownloader:
                 )
                 try:
                     # Read the series
-                    with simpleitk_warning_file.open("w") as f, stdout_redirected(
-                        f, stdout=sys.stderr
+                    with (
+                        simpleitk_warning_file.open("w") as f,
+                        stdout_redirected(f, stdout=sys.stderr),
                     ):
-                        series_reader.SetFileNames(files)  # type: ignore
-                        image = series_reader.Execute()  # type: ignore
+                        series_reader.SetFileNames(files)
+                        image = series_reader.Execute()
                     with simpleitk_warning_file.open("r") as f:
                         content = f.read()
                     if "warning" in content.lower():
@@ -431,9 +445,9 @@ class DicomDownloader:
                         series_download_dir / f"{series}_meta.dcm",
                     )
                 dcm_info = pydicom.dcmread(str(files[0]), stop_before_pixels=True)
-                current_dict[
-                    self.deid_study_instance_uid_field
-                ] = dcm_info.StudyInstanceUID
+                current_dict[self.deid_study_instance_uid_field] = (
+                    dcm_info.StudyInstanceUID
+                )
                 current_dict[self.deid_series_instance_uid_field] = series
                 downloaded_series_info.append(current_dict)
 
@@ -442,7 +456,7 @@ class DicomDownloader:
     def fix_mapping_dataframe(
         self,
         df: pd.DataFrame,
-        mapping_df: pd.DataFrame = None,
+        mapping_df: Optional[pd.DataFrame] = None,
         output_dir: Union[str, pathlib.Path] = "out",
         study_uid_col: str = "study_instance_uid",
         series_uid_col: str = "series_instance_uid",
@@ -464,7 +478,8 @@ class DicomDownloader:
         output_dir = pathlib.Path(output_dir)
         if not output_dir.exists() or not len(list(output_dir.glob("*"))):
             warnings.warn(
-                "Cannot fix the mapping file if the output directory does not exist."
+                "Cannot fix the mapping file if the output directory does not exist.",
+                stacklevel=2,
             )
             return None
         if mapping_df is None:
@@ -547,7 +562,7 @@ class DicomDownloader:
         output_dir: Union[str, pathlib.Path] = "out",
         study_uid_col: str = "study_instance_uid",
         series_uid_col: Optional[str] = "series_instance_uid",
-        mapping_df: pd.DataFrame = None,
+        mapping_df: Optional[pd.DataFrame] = None,
         download_full_study: bool = False,
         save_metadata: bool = True,
     ) -> Tuple[pd.DataFrame, pd.DataFrame]:
@@ -593,7 +608,8 @@ class DicomDownloader:
             warnings.warn(
                 "download_full_study = False will only download a specified series but "
                 "have not provided a valid Series UID column of the DataFrame, "
-                "as a result the full study will be downloaded."
+                "as a result the full study will be downloaded.",
+                stacklevel=2,
             )
 
         # Create list of rows

fhir_pyrate/miner.py

@@ -29,9 +29,9 @@ class Miner:
     def __init__(
         self,
         target_regex: str,
-        negation_regex: str = None,
-        regex_flags: Union[int, re.RegexFlag] = None,
-        decode_text: Callable = None,
+        negation_regex: Optional[str] = None,
+        regex_flags: Optional[Union[int, re.RegexFlag]] = None,
+        decode_text: Optional[Callable[[str], str]] = None,
         nlp_lib: str = "de_core_news_sm",
         num_processes: int = 1,
     ) -> None:
@@ -49,6 +49,7 @@ class Miner:
                 "this will probably not work, because it needs access to your home "
                 "directory. Please run python -m spacy download {nlp_lib} in your "
                 "docker file.",
+                stacklevel=2,
             )
             subprocess.run(
                 f"python3 -m spacy download {nlp_lib}".split(" "),
@@ -66,7 +67,7 @@ class Miner:
     @staticmethod
     def _remove_header(sentences: List[Span], main_document_keyword: str) -> List[Span]:
         """
-        Removes all sentences that come before a sentence that contains the `main_document_keyword`.
+        Remove all sentences that come before a sentence that contains the `main_document_keyword`.
         This is useful when a document has a header, and we know what the first viable word of a
         document is, or we know that we are interested in some particular part of the
         document that comes after a certain keyword.
@@ -86,10 +87,10 @@ class Miner:
     def _check_diagnostic_report(
         self,
         report_text: str,
-        main_document_keyword: str = "",
+        main_document_keyword: Optional[str] = "",
     ) -> Optional[List[Span]]:
         """
-        Checks whether a report contains the relevant RegEx and does not contain the negation
+        Check whether a report contains the relevant RegEx and does not contain the negation
         RegEx (if specified).
 
         :param report_text: The text to be searched
@@ -103,7 +104,7 @@ class Miner:
         contains_target = re.search(self.target_regex, report_text, self.regex_flags)
         relevant_sentences = []
         if contains_target:
-            sentences = [i for i in self.nlp(report_text).sents]
+            sentences = list(self.nlp(report_text).sents)
             if main_document_keyword is not None:
                 sentences = self._remove_header(sentences, main_document_keyword)
 
@@ -129,10 +130,10 @@ class Miner:
         df: pd.DataFrame,
         text_column_name: str,
         new_column_name: str = "text_found",
-        main_document_keyword: str = None,
+        main_document_keyword: Optional[str] = None,
     ) -> pd.DataFrame:
         """
-        Searches the strings contained in `text_column_name` for the selected RegEx, and adds two
+        Search the strings contained in `text_column_name` for the selected RegEx, and adds two
         columns to the DataFrame with the output of the NLP search. The negation RegEx can be
         used to exclude sentences. Additionally, it is possible to define a `main_document_keyword`,
         which is a string that can be used to filter out the header of the document.
@@ -151,31 +152,29 @@ class Miner:
             self._check_diagnostic_report,
             main_document_keyword=main_document_keyword,
         )
-        texts = [row for row in df[text_column_name].values]
+        texts = list(df[text_column_name].values)
         tqdm_text = f"Searching for Sentences with {self.target_regex}"
         if self.negation_regex is not None:
             tqdm_text += f" and without {self.negation_regex}"
         if self.num_processes > 1:
             pool = multiprocessing.Pool(self.num_processes)
-            results = [
-                result
-                for result in tqdm(
+            results = list(
+                tqdm(
                     pool.imap(func, texts),
                     total=len(df),
                     desc=tqdm_text,
                 )
-            ]
+            )
             pool.close()
             pool.join()
         else:
-            results = [
-                result
-                for result in tqdm(
+            results = list(
+                tqdm(
                     [func(text) for text in texts],
                     total=len(df),
                     desc=tqdm_text,
                 )
-            ]
+            )
 
         df[new_column_name + "_sentences"] = results
         df[new_column_name] = ~df[new_column_name + "_sentences"].isna()

fhir_pyrate/pirate.py

@@ -9,9 +9,22 @@ import warnings
 from functools import partial
 from pathlib import Path
 from types import TracebackType
-from typing import Any, Callable, Dict, Generator, List, Optional, Tuple, Type, Union
+from typing import (
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    Generator,
+    Iterable,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeAlias,
+    TypeVar,
+    Union,
+)
 
-import fhirpathpy
 import pandas as pd
 import requests
 from dateutil.parser import parse
@@ -23,13 +36,21 @@ from tqdm.contrib.logging import logging_redirect_tqdm
 from fhir_pyrate import Ahoy
 from fhir_pyrate.util import FHIRObj, string_from_column
 from fhir_pyrate.util.bundle_processing_templates import flatten_data, parse_fhir_path
+from fhir_pyrate.util.imports import optional_import
+
+TParam = TypeVar("TParam")
+TFHIRObj = TypeVar("TFHIRObj", bound=FHIRObj)
+ProcessFunc: TypeAlias = Callable[[FHIRObj], Any]
+
+# Note to people from the future. This actually should be an optional import to avoid that, if people want to use another version of antlr, this creates crazy errors that the version does not match. In such cases, it is not possible to use fhirpathpy, but the processing functions can still be used.
+fhirpathpy, _ = optional_import(module="fhirpathpy")
 
 logger = logging.getLogger(__name__)
 
 
 def create_key(request: requests.PreparedRequest, **kwargs: Any) -> str:
     """
-    Creates a unique key for each request URL.
+    Create a unique key for each request URL.
 
     :param request: The request to create a key for
     :param kwargs: Unused, needed for compatibility with the library
@@ -73,7 +94,7 @@ class Pirate:
     :param optional_get_params: Optional parameters that will be passed to the session's get calls
     """
 
-    FHIRPATH_INVALID_TOKENS = [
+    FHIRPATH_INVALID_TOKENS: ClassVar[Tuple[str, ...]] = (
         "div",
         "mod",
         "in",
@@ -81,7 +102,7 @@ class Pirate:
         "or",
         "xor",
         "implies",
-    ]
+    )
 
     def __init__(
         self,
@@ -90,14 +111,14 @@ class Pirate:
         num_processes: int = 1,
         print_request_url: bool = False,
         time_format: str = "%Y-%m-%dT%H:%M",
-        default_count: int = None,
-        cache_folder: Union[str, Path] = None,
+        default_count: Optional[int] = None,
+        cache_folder: Optional[Union[str, Path]] = None,
         cache_expiry_time: Union[datetime.datetime, int] = -1,  # -1 = does not expire
-        retry_requests: Retry = None,
+        retry_requests: Optional[Retry] = None,
         disable_multiprocessing_requests: bool = False,
         disable_multiprocessing_build: bool = False,
         silence_fhirpath_warning: bool = False,
-        optional_get_params: Dict[Any, Any] = None,
+        optional_get_params: Optional[Dict[Any, Any]] = None,
     ):
         # Remove the last character if they added it
         url_search = re.search(
@@ -179,7 +200,7 @@ class Pirate:
     def get_bundle_total(
         self,
         resource_type: str,
-        request_params: Dict[str, Any] = None,
+        request_params: Optional[Dict[str, Any]] = None,
         count_entries: bool = False,
     ) -> Optional[int]:
         """
@@ -203,11 +224,11 @@ class Pirate:
     def steal_bundles(
         self,
         resource_type: str,
-        request_params: Dict[str, Any] = None,
+        request_params: Optional[Dict[str, Any]] = None,
         num_pages: int = -1,
     ) -> Generator[FHIRObj, None, int]:
         """
-        Executes a request, iterates through the result pages and returns all the bundles as a
+        Execute a request, iterates through the result pages and returns all the bundles as a
         generator.
 
         :param resource_type: The resource to be queried, e.g. DiagnosticReport
@@ -230,14 +251,14 @@ class Pirate:
     def steal_bundles_to_dataframe(
         self,
         resource_type: str,
-        request_params: Dict[str, Any] = None,
+        request_params: Optional[Dict[str, Any]] = None,
         num_pages: int = -1,
-        process_function: Callable[[FHIRObj], Any] = flatten_data,
-        fhir_paths: List[Union[str, Tuple[str, str]]] = None,
+        process_function: ProcessFunc = flatten_data,
+        fhir_paths: Optional[List[Union[str, Tuple[str, str]]]] = None,
         build_df_after_query: bool = False,
     ) -> Union[pd.DataFrame, Dict[str, pd.DataFrame]]:
         """
-        Executes a request, iterates through the result pages, and builds a DataFrame with their
+        Execute a request, iterates through the result pages, and builds a DataFrame with their
         information. The DataFrames are either built after each
         bundle is retrieved, or after we collected all bundles.
 
@@ -276,10 +297,10 @@ class Pirate:
         time_attribute_name: str,
         date_init: Union[str, datetime.date],
         date_end: Union[str, datetime.date],
-        request_params: Dict[str, Any] = None,
+        request_params: Optional[Dict[str, Any]] = None,
     ) -> Generator[FHIRObj, None, int]:
         """
-        Uses the multiprocessing module to speed up some queries. The time frame is
+        Use the multiprocessing module to speed up some queries. The time frame is
         divided into multiple time spans (as many as there are processes) and each smaller
         time frame is investigated simultaneously.
 
@@ -307,13 +328,13 @@ class Pirate:
         time_attribute_name: str,
         date_init: Union[str, datetime.date],
         date_end: Union[str, datetime.date],
-        request_params: Dict[str, Any] = None,
-        process_function: Callable[[FHIRObj], Any] = flatten_data,
-        fhir_paths: List[Union[str, Tuple[str, str]]] = None,
+        request_params: Optional[Dict[str, Any]] = None,
+        process_function: ProcessFunc = flatten_data,
+        fhir_paths: Optional[List[Union[str, Tuple[str, str]]]] = None,
         build_df_after_query: bool = False,
     ) -> Union[pd.DataFrame, Dict[str, pd.DataFrame]]:
         """
-        Uses the multiprocessing module to speed up some queries. The time frame is
+        Use the multiprocessing module to speed up some queries. The time frame is
         divided into multiple time spans (as many as there are processes) and each smaller
         time frame is investigated simultaneously. Finally, it builds a DataFrame with the
         information from all timespans. The DataFrames are either built after each
@@ -357,7 +378,7 @@ class Pirate:
         df_constraints: Dict[
             str, Union[Union[str, Tuple[str, str]], List[Union[str, Tuple[str, str]]]]
         ],
-        request_params: Dict[str, Any] = None,
+        request_params: Optional[Dict[str, Any]] = None,
         num_pages: int = -1,
     ) -> Generator[FHIRObj, None, int]:
         """
@@ -398,12 +419,12 @@ class Pirate:
         df_constraints: Dict[
             str, Union[Union[str, Tuple[str, str]], List[Union[str, Tuple[str, str]]]]
         ],
-        process_function: Callable[[FHIRObj], Any] = flatten_data,
-        fhir_paths: List[Union[str, Tuple[str, str]]] = None,
-        request_params: Dict[str, Any] = None,
+        process_function: ProcessFunc = flatten_data,
+        fhir_paths: Optional[List[Union[str, Tuple[str, str]]]] = None,
+        request_params: Optional[Dict[str, Any]] = None,
         num_pages: int = -1,
         with_ref: bool = True,
-        with_columns: List[Union[str, Tuple[str, str]]] = None,
+        with_columns: Optional[List[Union[str, Tuple[str, str]]]] = None,
         build_df_after_query: bool = False,
     ) -> Union[pd.DataFrame, Dict[str, pd.DataFrame]]:
         """
@@ -549,7 +570,7 @@ class Pirate:
             ):
                 # If we don't want multiprocessing
                 for param, input_param in tqdm(
-                    zip(params_per_sample, input_params_per_sample),
+                    zip(params_per_sample, input_params_per_sample, strict=False),
                     total=len(params_per_sample),
                     desc=tqdm_text,
                 ):
@@ -573,7 +594,7 @@ class Pirate:
                 pool = multiprocessing.Pool(self.num_processes)
                 results = []
                 for param, input_param in tqdm(
-                    zip(params_per_sample, input_params_per_sample),
+                    zip(params_per_sample, input_params_per_sample, strict=False),
                     total=len(params_per_sample),
                     desc=tqdm_text,
                 ):
@@ -582,13 +603,13 @@ class Pirate:
                         (
                             pool.apply_async(
                                 self._bundles_to_dataframe,
-                                kwds=dict(
-                                    bundles=[b for b in self._get_bundles(**param)],
-                                    process_function=process_function,
-                                    build_df_after_query=False,
-                                    disable_multiprocessing=True,
-                                    always_return_dict=True,
-                                ),
+                                kwds={
+                                    "bundles": list(self._get_bundles(**param)),
+                                    "process_function": process_function,
+                                    "build_df_after_query": False,
+                                    "disable_multiprocessing": True,
+                                    "always_return_dict": True,
+                                },
                             ),
                             input_param,
                         )
@@ -610,13 +631,13 @@ class Pirate:
                 resource_type: pd.concat(final_dfs[resource_type], ignore_index=True)
                 for resource_type in final_dfs
             }
-            return list(dfs.values())[0] if len(dfs) == 1 else dfs
+            return next(iter(dfs.values())) if len(dfs) == 1 else dfs
 
     def bundles_to_dataframe(
         self,
         bundles: Union[List[FHIRObj], Generator[FHIRObj, None, int]],
-        process_function: Callable[[FHIRObj], Any] = flatten_data,
-        fhir_paths: List[Union[str, Tuple[str, str]]] = None,
+        process_function: ProcessFunc = flatten_data,
+        fhir_paths: Optional[List[Union[str, Tuple[str, str]]]] = None,
     ) -> Union[pd.DataFrame, Dict[str, pd.DataFrame]]:
         """
         Convert a bundle into a DataFrame using either the `flatten_data` function (default),
@@ -783,7 +804,7 @@ class Pirate:
     def _adjust_df_constraints(
         df_constraints: Dict[
             str, Union[Union[str, Tuple[str, str]], List[Union[str, Tuple[str, str]]]]
-        ]
+        ],
     ) -> Dict[str, List[Tuple[str, str]]]:
         """
         Adjust the constraint dictionary to always have the same structure, which makes it easier
@@ -835,7 +856,7 @@ class Pirate:
         df_constraints: Dict[str, List[Tuple[str, str]]],
     ) -> List[Dict[str, List[str]]]:
         """
-        Builds the request parameters for each sample by checking the constraint set on each row.
+        Build the request parameters for each sample by checking the constraint set on each row.
         The resulting request parameters are given by the general `request_params` and by the
         constraint given by each row. E.g. if df_constraints = {"subject": "patient_id"}, then
         the resulting list will contain {"subject": row.patient_id} for each row of the DataFrame.
@@ -911,7 +932,7 @@ class Pirate:
 
     def _get_response(self, request_url: str) -> Optional[FHIRObj]:
         """
-        Performs the API request and returns the response as a dictionary.
+        Perform the API request and returns the response as a dictionary.
 
         :param request_url: The request string
         :return: A FHIR bundle
@@ -985,13 +1006,13 @@ class Pirate:
     def _get_bundles(
         self,
         resource_type: str,
-        request_params: Dict[str, Any] = None,
+        request_params: Optional[Dict[str, Any]] = None,
         num_pages: int = -1,
         silence_tqdm: bool = False,
         tqdm_df_build: bool = False,
     ) -> Generator[FHIRObj, None, int]:
         """
-        Executes a request, iterates through the result pages and returns all the bundles as a
+        Execute a request, iterates through the result pages and returns all the bundles as a
         generator.
         Additionally, some checks are performed, and the corresponding warnings are returned:
         - Whether a sorting has been defined
@@ -1031,7 +1052,8 @@ class Pirate:
             warnings.warn(
                 f"We detected multiple pages (approximately {bundle_total} pages) but "
                 f"no sorting method has been defined, which may yield incorrect results. "
-                f"We will set the sorting parameter to _id."
+                f"We will set the sorting parameter to _id.",
+                stacklevel=2,
             )
             current_params["_sort"] = "_id"
             request_params_string = self._concat_request_params(current_params)
@@ -1080,7 +1102,7 @@ class Pirate:
         tqdm_df_build: bool,
     ) -> Generator[FHIRObj, None, int]:
         """
-        Wrapper function that sets the `time_attribute_name` date parameters for the
+        Set the `time_attribute_name` date parameters for the
         `sail_through_search_space function`.
         """
         request_params[time_attribute_name] = (
@@ -1096,9 +1118,11 @@ class Pirate:
         )
 
     @staticmethod
-    def _generator_to_list(f: Callable, *args: Any, **kwargs: Any) -> List[FHIRObj]:
+    def _generator_to_list(
+        f: Callable[..., Iterable[TFHIRObj]], *args: Any, **kwargs: Any
+    ) -> List[FHIRObj]:
         """
-        Wrapper function that converts the result of a function returning a generator to a list.
+        Convert the result of a function returning a generator to a list.
         """
         return list(f(*args, **kwargs))
 
@@ -1108,7 +1132,7 @@ class Pirate:
 
     def _run_multiquery(
         self,
-        func: Callable,
+        func: Callable[[TParam], Iterable[TFHIRObj]],
         query_params: List[Any],
         tqdm_text: str,
     ) -> Generator[FHIRObj, None, int]:
@@ -1139,11 +1163,11 @@ class Pirate:
         time_attribute_name: str,
         date_init: Union[str, datetime.date],
         date_end: Union[str, datetime.date],
-        request_params: Dict[str, Any] = None,
+        request_params: Optional[Dict[str, Any]] = None,
         tqdm_df_build: bool = False,
     ) -> Generator[FHIRObj, None, int]:
         """
-        Uses the multiprocessing module to speed up some queries. The time frame is
+        Use the multiprocessing module to speed up some queries. The time frame is
         divided into multiple time spans (as many as there are processes) and each smaller
         time frame is investigated simultaneously.
 
@@ -1169,7 +1193,8 @@ class Pirate:
                 warnings.warn(
                     f"Detected use of parameter {time_attribute_name} "
                     f"in the request parameters. Please use the date_init (inclusive) and "
-                    f"date_end (exclusive) parameters instead."
+                    f"date_end (exclusive) parameters instead.",
+                    stacklevel=2,
                 )
                 # Remove all elements that refer to a date
                 request_params = {
@@ -1189,7 +1214,7 @@ class Pirate:
             )
             # Divide the current time period into smaller spans
             timespans = self._get_timespan_list(date_init, date_end)
-            func: Callable = partial(
+            func = partial(
                 self._get_bundles_for_timespan,
                 resource_type,
                 request_params,
@@ -1213,7 +1238,7 @@ class Pirate:
         df_constraints: Dict[
             str, Union[Union[str, Tuple[str, str]], List[Union[str, Tuple[str, str]]]]
         ],
-        request_params: Dict[str, Any] = None,
+        request_params: Optional[Dict[str, Any]] = None,
         num_pages: int = -1,
         tqdm_df_build: bool = False,
     ) -> Generator[FHIRObj, None, int]:
@@ -1246,7 +1271,7 @@ class Pirate:
                 request_params=request_params,
                 df_constraints=self._adjust_df_constraints(df_constraints),
             )
-            func: Callable = partial(
+            func = partial(
                 self._get_bundles,
                 resource_type,
                 num_pages=num_pages,
@@ -1278,16 +1303,17 @@ class Pirate:
             if key_mapping[key] in df.columns:
                 warnings.warn(
                     f"A column with name {key_mapping[key]} already exists in the output"
-                    f"DataFrame, and the column {key} will not be copied."
+                    f"DataFrame, and the column {key} will not be copied.",
+                    stacklevel=2,
                 )
             else:
                 df[key_mapping[key]] = value
 
     def _set_up_fhirpath_function(
         self, fhir_paths: List[Union[str, Tuple[str, str]]]
-    ) -> Callable:
+    ) -> ProcessFunc:
         """
-        Prepares and compiles the FHIRPath and sets them as the processing function for building
+        Prepare and compile the FHIRPath and sets them as the processing function for building
         the DataFrames.
         :param fhir_paths: A list of FHIR paths (https://hl7.org/fhirpath/) to be used to build the
         DataFrame, alternatively, a list of tuples can be used to specify the column name of the
@@ -1316,17 +1342,18 @@ class Pirate:
                             f"If you really want to do this, please use processing functions "
                             f"instead. If you are using the FHIRPath expressions correctly as "
                             f"they are intended, you can silence the warning when "
-                            f"initializing the class."
+                            f"initializing the class.",
+                            stacklevel=2,
                         )
-        fhir_paths_with_name = [
+        compiled_paths = [
             (name, fhirpathpy.compile(path=path)) for name, path in fhir_paths_with_name
         ]
-        return partial(parse_fhir_path, compiled_fhir_paths=fhir_paths_with_name)
+        return partial(parse_fhir_path, compiled_fhir_paths=compiled_paths)
 
     def _bundles_to_dataframe(
         self,
-        bundles: Union[List[FHIRObj], Generator[FHIRObj, None, int]],
-        process_function: Callable[[FHIRObj], Any] = flatten_data,
+        bundles: Iterable[FHIRObj],
+        process_function: ProcessFunc = flatten_data,
         build_df_after_query: bool = False,
         disable_multiprocessing: bool = False,
         always_return_dict: bool = False,
@@ -1354,19 +1381,15 @@ class Pirate:
             pool = multiprocessing.Pool(self.num_processes)
             if build_df_after_query or isinstance(bundles, List):
                 bundles = list(bundles)
-                processed_bundles = [
-                    bundle_output
-                    for bundle_output in tqdm(
+                processed_bundles = list(
+                    tqdm(
                         pool.imap(process_function, bundles),
                         total=len(bundles),
                         desc="Build DF",
                     )
-                ]
+                )
             else:
-                processed_bundles = [
-                    bundle_output
-                    for bundle_output in pool.imap(process_function, bundles)
-                ]
+                processed_bundles = list(pool.imap(process_function, bundles))
             pool.close()
             pool.join()
         results: Dict[str, List[Dict[str, Any]]] = {}
@@ -1385,14 +1408,14 @@ class Pirate:
         if always_return_dict:
             return dfs
         else:
-            return list(dfs.values())[0] if len(dfs) == 1 else dfs
+            return next(iter(dfs.values())) if len(dfs) == 1 else dfs
 
     def _query_to_dataframe(
         self,
-        bundles_function: Callable,
-    ) -> Callable:
+        bundles_function: Callable[..., Iterable[FHIRObj]],
+    ) -> Callable[..., Union[pd.DataFrame, Dict[str, pd.DataFrame]]]:
         """
-        Wrapper function that can be used to transform any function return Lists/Generators of
+        Transform any function return Lists/Generators of
         bundles into DataFrames.
 
         :param bundles_function: The function that returns a Generator/List of bundles and that
@@ -1401,8 +1424,8 @@ class Pirate:
         """
 
         def wrap(
-            process_function: Callable[[FHIRObj], Any] = flatten_data,
-            fhir_paths: List[Union[str, Tuple[str, str]]] = None,
+            process_function: ProcessFunc = flatten_data,
+            fhir_paths: Optional[List[Union[str, Tuple[str, str]]]] = None,
             build_df_after_query: bool = False,
             disable_multiprocessing_build: bool = False,
             always_return_dict: bool = False,
@@ -1430,14 +1453,16 @@ class Pirate:
 
     def query_to_dataframe(
         self,
-        bundles_function: Callable,
-        process_function: Callable[[FHIRObj], Any] = flatten_data,
-        fhir_paths: List[Union[str, Tuple[str, str]]] = None,
+        bundles_function: Callable[
+            ..., Union[List[FHIRObj], Generator[FHIRObj, None, int]]
+        ],
+        process_function: ProcessFunc = flatten_data,
+        fhir_paths: Optional[List[Union[str, Tuple[str, str]]]] = None,
         build_df_after_query: bool = False,
         **kwargs: Any,
     ) -> Union[pd.DataFrame, Dict[str, pd.DataFrame]]:
         """
-        Wrapper function that given any of the functions that return bundles, builds the
+        Given any of the functions that return bundles, builds the
         DataFrame straight away.
         :param bundles_function: The function that should be used to get the bundles,
         e.g. self.sail_through_search_space, trade_rows_for_bundles

fhir_pyrate/util/__init__.py

@@ -1,4 +1,4 @@
 from fhir_pyrate.util.fhirobj import FHIRObj
 from fhir_pyrate.util.util import get_datetime, now_utc, string_from_column
 
-__all__ = ["string_from_column", "get_datetime", "FHIRObj", "now_utc"]
+__all__ = ["FHIRObj", "get_datetime", "now_utc", "string_from_column"]

fhir_pyrate/util/bundle_processing_templates.py

@@ -7,7 +7,9 @@ from fhir_pyrate.util import FHIRObj
 logger = logging.getLogger(__name__)
 
 
-def flatten_data(bundle: FHIRObj, col_sep: str = "_") -> Dict[str, List[Dict]]:
+def flatten_data(
+    bundle: FHIRObj, col_sep: str = "_"
+) -> Dict[str, List[Dict[str, Any]]]:
     """
     Preprocessing function that goes through the JSON bundle and returns lists of dictionaries
     for all possible attributes
@@ -68,8 +70,8 @@ def recurse_resource(
 
 
 def parse_fhir_path(
-    bundle: FHIRObj, compiled_fhir_paths: List[Tuple[str, Callable]]
-) -> Dict[str, List[Dict]]:
+    bundle: FHIRObj, compiled_fhir_paths: List[Tuple[str, Callable[..., Any]]]
+) -> Dict[str, List[Dict[str, Any]]]:
     """
     Preprocessing function that goes through the JSON bundle and returns lists of dictionaries
     for all possible attributes, which have been specified using a list of compiled FHIRPath
@@ -93,7 +95,8 @@ def parse_fhir_path(
             if name in base_dict and base_dict[name] is not None and len(result) > 0:
                 warnings.warn(
                     f"The field {name} has already been filled with {base_dict[name]}, "
-                    f"so it will not be overwritten."
+                    f"so it will not be overwritten.",
+                    stacklevel=2,
                 )
             if name not in base_dict or base_dict[name] is None:
                 base_dict[name] = result

fhir_pyrate/util/fhirobj.py

@@ -17,10 +17,10 @@ class FHIRObj(SimpleNamespace):
     def __getattr__(self, item: str) -> None:
         return None
 
-    def __getstate__(self) -> Dict:
+    def __getstate__(self) -> Dict[str, Any]:
         return self.__dict__
 
-    def __setstate__(self, state: Dict) -> None:
+    def __setstate__(self, state: Dict[str, Any]) -> None:
         self.__dict__.update(state)
 
     def to_json(self) -> str:

fhir_pyrate/util/imports.py

@@ -40,7 +40,7 @@ def optional_import(
     allow_namespace_pkg: bool = False,
 ) -> Tuple[Any, bool]:
     """
-    Imports an optional module specified by `module` string.
+    Import an optional module specified by `module` string.
     Any importing related exceptions will be stored, and exceptions raise lazily
     when attempting to use the failed-to-import module.
 
@@ -100,14 +100,14 @@ def optional_import(
 
         def __getattr__(self, name: str) -> str:
             """
-            Raises:
+            Raise:
                 OptionalImportError: When you call this method.
             """
             raise self._exception
 
         def __call__(self, *_args: Any, **_kwargs: Any) -> str:
             """
-            Raises:
+            Raise:
                 OptionalImportError: When you call this method.
             """
             raise self._exception

fhir_pyrate/util/token_auth.py

@@ -37,10 +37,10 @@ class TokenAuth(requests.auth.AuthBase):
         username: str,
         password: str,
         auth_url: str,
-        refresh_url: str = None,
-        session: requests.Session = None,
+        refresh_url: Optional[str] = None,
+        session: Optional[requests.Session] = None,
         max_login_attempts: int = 5,
-        token_refresh_delta: Union[int, timedelta] = None,
+        token_refresh_delta: Optional[Union[int, timedelta]] = None,
     ) -> None:
         self._username = username
         self._password = password
@@ -69,7 +69,7 @@ class TokenAuth(requests.auth.AuthBase):
 
     def _authenticate(self) -> None:
         """
-        Authenticates the user using the authentication URL and sets the token.
+        Authenticate the user using the authentication URL and sets the token.
         """
         # Authentication to get the token
         response = self._token_session.get(
@@ -80,7 +80,7 @@ class TokenAuth(requests.auth.AuthBase):
 
     def __call__(self, r: requests.PreparedRequest) -> requests.PreparedRequest:
         """
-        Sets the necessary authentication header of the current request.
+        Set the necessary authentication header of the current request.
 
         :param r: The prepared request that should be sent
         :return: The prepared request
@@ -90,7 +90,7 @@ class TokenAuth(requests.auth.AuthBase):
 
     def is_refresh_required(self) -> bool:
         """
-        Computes whether the token should be refreshed according to the given token and to the
+        Compute whether the token should be refreshed according to the given token and to the
         _token_refresh_delta variable.
 
         :return: Whether the token is about to expire and should thus be refreshed
@@ -123,7 +123,7 @@ class TokenAuth(requests.auth.AuthBase):
                 and (now_utc() - self.auth_time) > self._token_refresh_delta
             )
 
-    def refresh_token(self, token: str = None) -> None:
+    def refresh_token(self, token: Optional[str] = None) -> None:
         """
         Refresh the current session either by logging in again or by refreshing the token.
 
@@ -150,7 +150,7 @@ class TokenAuth(requests.auth.AuthBase):
         self, response: requests.Response, *args: Any, **kwargs: Any
     ) -> Optional[requests.Response]:
         """
-        Hook that is called after every request, it checks whether the login was successful and
+        Check whether the login was successful and
         if it was not, it either refreshes the token or authenticates the user again.
 
         :param response: The received response
@@ -166,16 +166,14 @@ class TokenAuth(requests.auth.AuthBase):
             # If the state is unauthorized,
             # then we should set how many times we have tried logging in
             if response.status_code == requests.codes.unauthorized:
-                if hasattr(response.request, "login_reattempted_times"):
-                    logger.info("Refreshing token because of unauthorized status.")
-                    response.request.login_reattempted_times += 1  # type: ignore
-                    if (
-                        response.request.login_reattempted_times  # type: ignore
-                        >= self._max_login_attempts
-                    ):
-                        response.raise_for_status()
-                else:
-                    response.request.login_reattempted_times = 1  # type: ignore
+                login_attempts: int = getattr(
+                    response.request, "login_reattempted_times", 0
+                )
+                logger.info("Refreshing token because of unauthorized status.")
+                login_attempts += 1
+                if login_attempts >= self._max_login_attempts:
+                    response.raise_for_status()
+                setattr(response.request, "login_reattempted_times", login_attempts)  # noqa
             else:
                 logger.info("Refreshing token refresh is required.")
 

fhir_pyrate/util/util.py

@@ -16,7 +16,7 @@ def string_from_column(
     sort_reverse: bool = False,
 ) -> Any:
     """
-    Transforms the values contained in a pandas Series into a string of (if desired unique) values.
+    Transform the values contained in a pandas Series into a string of (if desired unique) values.
 
     :param col:
     :param separator: The separator for the values
@@ -25,7 +25,7 @@ def string_from_column(
     :param sort_reverse: Whether the values should sorted in reverse order
     :return: A string containing the values of the Series.
     """
-    existing_values = list()
+    existing_values = []
     for el in col.values:
         if not pd.isnull(el) and el != "":
             existing_values.append(el)
@@ -44,7 +44,7 @@ def string_from_column(
 
 def get_datetime(dt_format: str = "%Y-%m-%d %H:%M:%S") -> str:
     """
-    Creates a datetime string according to the given format
+    Create a datetime string according to the given format
 
     :param dt_format: The format to use for the printing
     :return: The formatted string

{fhir_pyrate-0.2.1.dist-info → fhir_pyrate-0.2.2.dist-info}/METADATA

@@ -1,19 +1,19 @@
 Metadata-Version: 2.1
 Name: fhir-pyrate
-Version: 0.2.1
+Version: 0.2.2
 Summary: FHIR-PYrate is a package that provides a high-level API to query FHIR Servers for bundles of resources and return the structured information as pandas DataFrames. It can also be used to filter resources using RegEx and SpaCy and download DICOM studies and series.
 Home-page: https://github.com/UMEssen/FHIR-PYrate
 License: MIT
 Keywords: python,fhir,data-science,fhirpath,healthcare
 Author: Rene Hosch
 Author-email: rene.hosch@uk-essen.de
-Requires-Python: >=3.8,<4.0
+Requires-Python: >=3.10,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: all
 Provides-Extra: downloader
 Provides-Extra: miner
@@ -21,8 +21,8 @@ Requires-Dist: PyJWT (>=2.4.0,<3.0.0)
 Requires-Dist: SimpleITK (>=2.0.2,<3.0.0) ; extra == "downloader" or extra == "all"
 Requires-Dist: dicomweb-client (>=0.52.0,<0.53.0) ; extra == "downloader" or extra == "all"
 Requires-Dist: fhirpathpy (>=0.2.2,<0.3.0)
-Requires-Dist: numpy (>=1.22,<2.0)
-Requires-Dist: pandas (>=1.3.0,<2.0.0)
+Requires-Dist: numpy (>=2.0.0,<3.0.0)
+Requires-Dist: pandas (>=2.0.0,<3.0.0)
 Requires-Dist: pydicom (>=2.1.2,<3.0.0) ; extra == "downloader" or extra == "all"
 Requires-Dist: requests (>=2.28.0,<3.0.0)
 Requires-Dist: requests-cache (>=0.9.7,<0.10.0)
@@ -32,18 +32,14 @@ Project-URL: Repository, https://github.com/UMEssen/FHIR-PYrate
 Description-Content-Type: text/markdown
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Supported Python version](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/release/python-380/)
+[![Supported Python version](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/release/python-31011/)
 [![Stable Version](https://img.shields.io/pypi/v/fhir-pyrate?label=stable)](https://pypi.org/project/fhir-pyrate/)
 [![Pre-release Version](https://img.shields.io/github/v/release/UMEssen/fhir-pyrate?label=pre-release&include_prereleases&sort=semver)](https://pypi.org/project/fhir-pyrate/#history)
 [![DOI](https://zenodo.org/badge/456893108.svg)](https://zenodo.org/badge/latestdoi/456893108)
+[![Affiliated with RTG WisPerMed](https://img.shields.io/badge/Affiliated-RTG%202535%20WisPerMed-blue)](https://wispermed.org/)
 
 <!-- PROJECT LOGO -->
-<br />
-<div align="center">
-  <a href="https://github.com/UMEssen/FHIR-PYrate">
-    <img src="https://raw.githubusercontent.com/UMEssen/FHIR-PYrate/main/images/logo.svg" alt="Logo" width="600">
-  </a>
-</div>
+![Pyrate-Banner](images/pyrate-banner.png)
 
 This package is meant to provide a simple abstraction to query and structure FHIR resources as
 pandas DataFrames. Want to use R instead? Try out [fhircrackr](https://github.com/POLAR-fhiR/fhircrackr)!

fhir_pyrate-0.2.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+fhir_pyrate/__init__.py,sha256=GrVFlghs2Q8pGCVLdNjD40R0Xt8ptvF5NhCtT1FUazk,864
+fhir_pyrate/ahoy.py,sha256=dOw94Khg3_4fXnJHAnZFlazxy_Tbb32Yi0HGOYVaHLU,5611
+fhir_pyrate/dicom_downloader.py,sha256=GNoOSlyt_pdykdcfvHS287iXMrVBHeyY1WIeegHnbvk,28215
+fhir_pyrate/miner.py,sha256=wydCL6zmVHSf4ctwz2760mZAfe9byVQciUWUQyRHVtQ,7331
+fhir_pyrate/pirate.py,sha256=xNqmz5g5EnB3-RLZM46JYXkoGISFVmYEQUg2M-bTcKA,70318
+fhir_pyrate/util/__init__.py,sha256=-P4jBpsH6XzQELrLAod2_P9oBocfaYUOWb_LQ-QjyKI,193
+fhir_pyrate/util/bundle_processing_templates.py,sha256=EERL26gbv2hkYCoxWj1ZguJK5TKJ3e03zMAJuKSkczY,4519
+fhir_pyrate/util/fhirobj.py,sha256=nTkSUbsmOisgDDgD_cEggF8hlPVjm7CWVSrkA8dOq3E,903
+fhir_pyrate/util/imports.py,sha256=3s0hvuonX_susm5anw4fZORh7V3JMJ4hoLPBVSoj7Lw,4333
+fhir_pyrate/util/token_auth.py,sha256=mfLzlZxCnWbiOOMZh_IDYgREp_9fhI3FshB8mDULtaQ,7862
+fhir_pyrate/util/util.py,sha256=1qIdoriWNksD3DRYm7qSRCli5t9524wa3mVf21fETgs,1507
+fhir_pyrate-0.2.2.dist-info/LICENSE,sha256=1IS7y51_JRtpCVVbUpYyztTMj3A6FskEZJBQkAQ9w9o,1084
+fhir_pyrate-0.2.2.dist-info/METADATA,sha256=V5L-hgjfdmrikX1nmZNsBHbf1utdOj-zSsQfKeV6ybQ,29679
+fhir_pyrate-0.2.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+fhir_pyrate-0.2.2.dist-info/RECORD,,

{fhir_pyrate-0.2.1.dist-info → fhir_pyrate-0.2.2.dist-info}/WHEEL

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

fhir_pyrate-0.2.1.dist-info/RECORD

@@ -1,15 +0,0 @@
-fhir_pyrate/__init__.py,sha256=-25N2f8w3P0YXynSIqZcp2naR5lq0Q4_Xag2TZ4Ln7g,864
-fhir_pyrate/ahoy.py,sha256=pjzqDTadeLLIozygOKA-h1762uNN5mRWiiTDVLiiFQU,5531
-fhir_pyrate/dicom_downloader.py,sha256=kmguN9-qmwFMwBlz9veMEiXX7mwTHsfqYtlKAS3sN3A,27955
-fhir_pyrate/miner.py,sha256=sCiRhvBRUB548g2M9PcV8AptODdTQzd_KXJ8YccZKNU,7327
-fhir_pyrate/pirate.py,sha256=Ay2XnfjW0HNseQ-yW45EtooZXiUtQNNb-9gIUU7BhgY,69474
-fhir_pyrate/util/__init__.py,sha256=vlDDL-4G8gvv544TBmYZtAuNpSc23APjJs_1R9vv5ag,193
-fhir_pyrate/util/bundle_processing_templates.py,sha256=rxeUCRKiMMblT_-c55kYm1JofdAAbmDgu5spfBy99uE,4448
-fhir_pyrate/util/fhirobj.py,sha256=GX6iwbXtBYpe_DiRag0fYF3qenaLD2bQh31WYPDke44,883
-fhir_pyrate/util/imports.py,sha256=jKxiMYTDjbmstqbGCGYjr6EAdbTsvOrZ7GSZo1W6y2g,4336
-fhir_pyrate/util/token_auth.py,sha256=JcEOYCjTP3DXNsMP-Szv3m0y1TO4-SEWAYl10PkPBks,7993
-fhir_pyrate/util/util.py,sha256=DIr5McePaG0m_Uu2B6BTUd2MExXH2PtN-cKOT7gtLRY,1513
-fhir_pyrate-0.2.1.dist-info/LICENSE,sha256=1IS7y51_JRtpCVVbUpYyztTMj3A6FskEZJBQkAQ9w9o,1084
-fhir_pyrate-0.2.1.dist-info/METADATA,sha256=BdfZnzPMip6fI_0WIy3q8_YIz6k6N9VH4kq9kC1rU1c,29707
-fhir_pyrate-0.2.1.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-fhir_pyrate-0.2.1.dist-info/RECORD,,