medicafe 0.250806.12__py3-none-any.whl → 0.250806.14__py3-none-any.whl

MediBot/MediBot_Crosswalk_Library.py

@@ -256,14 +256,33 @@ def crosswalk_update(client, config, crosswalk): # Upstream of this is only Medi
     api_cache = {}
 
     # Load insurance data from MAINS (optional - continue if not available)
+    # XP/Python34 Compatibility: Enhanced error handling with verbose output
     insurance_name_to_id = {}
     try:
         MediLink_ConfigLoader.log("Attempting to load insurance data from MAINS...", config, level="DEBUG")
-        insurance_name_to_id = MediBot_Preprocessor_lib.load_insurance_data_from_mains(config)
-        MediLink_ConfigLoader.log("Loaded insurance data from MAINS with {} entries.".format(len(insurance_name_to_id)), config, level="INFO")
+        
+        if MediBot_Preprocessor_lib and hasattr(MediBot_Preprocessor_lib, 'load_insurance_data_from_mains'):
+            insurance_name_to_id = MediBot_Preprocessor_lib.load_insurance_data_from_mains(config)
+            if insurance_name_to_id:
+                MediLink_ConfigLoader.log("Loaded insurance data from MAINS with {} entries.".format(len(insurance_name_to_id)), config, level="INFO")
+            else:
+                MediLink_ConfigLoader.log("load_insurance_data_from_mains returned empty data", config, level="WARNING")
+        else:
+            error_msg = "MediBot_Preprocessor_lib or load_insurance_data_from_mains not available"
+            MediLink_ConfigLoader.log(error_msg, config, level="WARNING")
+            print("Warning: {}".format(error_msg))
+            
+    except AttributeError as e:
+        error_msg = "AttributeError accessing load_insurance_data_from_mains: {}".format(str(e))
+        MediLink_ConfigLoader.log(error_msg, config, level="WARNING")
+        print("Warning: {}. Some crosswalk features may be limited.".format(error_msg))
+    except ImportError as e:
+        error_msg = "ImportError with MediBot_Preprocessor_lib: {}".format(str(e))
+        MediLink_ConfigLoader.log(error_msg, config, level="WARNING")
+        print("Warning: {}. Some crosswalk features may be limited.".format(error_msg))
     except Exception as e:
         MediLink_ConfigLoader.log("Error loading insurance data from MAINS: {}. Continuing without MAINS data.".format(e), config, level="WARNING")
-        print("Warning: MAINS data not available. Some crosswalk features may be limited.")
+        print("Warning: MAINS data not available ({}). Some crosswalk features may be limited.".format(str(e)))
         # Continue without MAINS data - don't return False
 
     # Load historical payer to patient mappings (optional - continue if not available)

MediBot/MediBot_Crosswalk_Utils.py

@@ -459,13 +459,32 @@ def update_crosswalk_with_new_payer_id(client, insurance_name, payer_id, config,
         return False
     
     # Load the Medisoft ID for the given insurance name
+    # XP/Python34 Compatibility: Enhanced error handling with verbose output
     try:
         # Note: MediBot_Preprocessor_lib is imported at module level
-        medisoft_id = MediBot_Preprocessor_lib.load_insurance_data_from_mains(config).get(insurance_name)
+        if MediBot_Preprocessor_lib and hasattr(MediBot_Preprocessor_lib, 'load_insurance_data_from_mains'):
+            insurance_data = MediBot_Preprocessor_lib.load_insurance_data_from_mains(config)
+            medisoft_id = insurance_data.get(insurance_name) if insurance_data else None
+            MediLink_ConfigLoader.log("Successfully retrieved insurance data for {}".format(insurance_name), config, level="DEBUG")
+        else:
+            error_msg = "MediBot_Preprocessor_lib or load_insurance_data_from_mains not available"
+            MediLink_ConfigLoader.log(error_msg, config, level="WARNING")
+            print("Warning: {}".format(error_msg))
+            medisoft_id = None
+    except AttributeError as e:
+        error_msg = "AttributeError accessing load_insurance_data_from_mains: {}".format(str(e))
+        MediLink_ConfigLoader.log(error_msg, config, level="WARNING")
+        print("Warning: {}".format(error_msg))
+        medisoft_id = None
     except KeyError as e:  # Handle KeyError for config
         MediLink_ConfigLoader.log("KeyError while loading Medisoft ID: {}".format(e), config, level="ERROR")
         print("KeyError while loading Medisoft ID for insurance name {}: {}".format(insurance_name, e))
         return False
+    except Exception as e:
+        error_msg = "Unexpected error loading insurance data: {}".format(str(e))
+        MediLink_ConfigLoader.log(error_msg, config, level="ERROR")
+        print("Error: {}".format(error_msg))
+        medisoft_id = None
 
     MediLink_ConfigLoader.log("Retrieved Medisoft ID for insurance name {}: {}.".format(insurance_name, medisoft_id), config, level="DEBUG")
     

MediCafe/api_core.py

@@ -138,24 +138,59 @@ class APIClient(BaseAPIClient):
         super().__init__(config)
         
         # Add enhanced features if available
+        # XP/Python34 Compatibility: Enhanced error handling with verbose output
         try:
             from MediCafe.api_utils import APICircuitBreaker, APICache, APIRateLimiter
+            MediLink_ConfigLoader.log("Successfully imported MediCafe.api_utils", level="DEBUG")
+        except ImportError as e:
+            MediLink_ConfigLoader.log("Warning: MediCafe.api_utils not available: {}".format(str(e)), level="WARNING")
+            print("Warning: MediCafe.api_utils import failed: {}".format(str(e)))
+            APICircuitBreaker = None
+            APICache = None
+            APIRateLimiter = None
+        except Exception as e:
+            MediLink_ConfigLoader.log("Unexpected error importing MediCafe.api_utils: {}".format(str(e)), level="ERROR")
+            print("Error: Unexpected MediCafe.api_utils import error: {}".format(str(e)))
+            APICircuitBreaker = None
+            APICache = None
+            APIRateLimiter = None
+        
+        try:
             from MediLink.MediLink_insurance_utils import get_feature_flag
-            
-            # Initialize enhancements if enabled
+            MediLink_ConfigLoader.log("Successfully imported MediLink.MediLink_insurance_utils", level="DEBUG")
+        except ImportError as e:
+            MediLink_ConfigLoader.log("Warning: MediLink.MediLink_insurance_utils not available: {}".format(str(e)), level="WARNING")
+            print("Warning: MediLink.MediLink_insurance_utils import failed: {}".format(str(e)))
+            # Provide fallback function
+            def get_feature_flag(flag_name, default=False):
+                MediLink_ConfigLoader.log("Using fallback get_feature_flag for '{}', returning default: {}".format(flag_name, default), level="DEBUG")
+                return default
+        except Exception as e:
+            MediLink_ConfigLoader.log("Unexpected error importing MediLink.MediLink_insurance_utils: {}".format(str(e)), level="ERROR")
+            print("Error: Unexpected MediLink.MediLink_insurance_utils import error: {}".format(str(e)))
+            # Provide fallback function
+            def get_feature_flag(flag_name, default=False):
+                MediLink_ConfigLoader.log("Using fallback get_feature_flag for '{}', returning default: {}".format(flag_name, default), level="DEBUG")
+                return default
+        
+        # Initialize enhancements with error handling
+        try:
             enable_circuit_breaker = get_feature_flag('api_circuit_breaker', default=False)
             enable_caching = get_feature_flag('api_caching', default=False)
             enable_rate_limiting = get_feature_flag('api_rate_limiting', default=False)
             
-            self.circuit_breaker = APICircuitBreaker() if enable_circuit_breaker else None
-            self.api_cache = APICache() if enable_caching else None
-            self.rate_limiter = APIRateLimiter() if enable_rate_limiting else None
+            self.circuit_breaker = APICircuitBreaker() if (enable_circuit_breaker and APICircuitBreaker) else None
+            self.api_cache = APICache() if (enable_caching and APICache) else None
+            self.rate_limiter = APIRateLimiter() if (enable_rate_limiting and APIRateLimiter) else None
             
             if any([enable_circuit_breaker, enable_caching, enable_rate_limiting]):
                 MediLink_ConfigLoader.log("Enhanced API client initialized with circuit_breaker={}, caching={}, rate_limiting={}".format(
                     enable_circuit_breaker, enable_caching, enable_rate_limiting), level="INFO")
-        except ImportError:
-            MediLink_ConfigLoader.log("API enhancements not available, using standard client", level="DEBUG")
+            else:
+                MediLink_ConfigLoader.log("API enhancements disabled or not available, using standard client", level="DEBUG")
+        except Exception as e:
+            MediLink_ConfigLoader.log("Error initializing API enhancements: {}. Using standard client.".format(str(e)), level="WARNING")
+            print("Warning: API enhancement initialization failed: {}".format(str(e)))
             self.circuit_breaker = None
             self.api_cache = None
             self.rate_limiter = None

MediCafe/api_factory.py

@@ -181,7 +181,23 @@ class APIClientFactory:
             
             return client
         
-        return self.circuit_breaker.call(create_client)
+        # XP/Python34 Compatibility: Wrap circuit breaker call with error handling
+        try:
+            if self.circuit_breaker and hasattr(self.circuit_breaker, 'call'):
+                return self.circuit_breaker.call(create_client)
+            else:
+                MediLink_ConfigLoader.log("Circuit breaker not available, calling create_client directly", level="WARNING")
+                return create_client()
+        except Exception as e:
+            MediLink_ConfigLoader.log("Circuit breaker call failed: {}. Falling back to direct client creation.".format(str(e)), level="WARNING")
+            print("Warning: Circuit breaker error ({}), using fallback client creation".format(str(e)))
+            try:
+                return create_client()
+            except Exception as e2:
+                MediLink_ConfigLoader.log("Direct client creation also failed: {}".format(str(e2)), level="ERROR")
+                print("Error: Both circuit breaker and direct client creation failed: {}".format(str(e2)))
+                # Return a minimal fallback client
+                return ProductionAPIClient()
     
     @classmethod
     def get_shared_client(cls, **kwargs):

MediLink/MediLink_837p_encoder_library.py

@@ -13,15 +13,29 @@ if project_dir not in sys.path:
     sys.path.append(project_dir)
 
 # Import MediBot modules conditionally to avoid circular imports
+# XP/Python34 Compatibility: Enhanced error handling with verbose output
 MediBot_Preprocessor_lib = None
 load_insurance_data_from_mains = None
 
 try:
     from MediBot import MediBot_Preprocessor_lib
+    MediLink_ConfigLoader.log("Successfully imported MediBot_Preprocessor_lib", level="DEBUG")
+    
     if hasattr(MediBot_Preprocessor_lib, 'load_insurance_data_from_mains'):
         load_insurance_data_from_mains = MediBot_Preprocessor_lib.load_insurance_data_from_mains
-except ImportError:
-    pass
+        MediLink_ConfigLoader.log("Successfully accessed load_insurance_data_from_mains function", level="DEBUG")
+    else:
+        MediLink_ConfigLoader.log("Warning: MediBot_Preprocessor_lib found but load_insurance_data_from_mains attribute missing", level="WARNING")
+        print("Warning: MediBot_Preprocessor_lib missing load_insurance_data_from_mains attribute")
+except ImportError as e:
+    MediLink_ConfigLoader.log("ImportError accessing MediBot_Preprocessor_lib: {}".format(str(e)), level="WARNING")
+    print("Warning: Cannot import MediBot_Preprocessor_lib: {}".format(str(e)))
+except AttributeError as e:
+    MediLink_ConfigLoader.log("AttributeError accessing load_insurance_data_from_mains: {}".format(str(e)), level="WARNING")
+    print("Warning: AttributeError with load_insurance_data_from_mains: {}".format(str(e)))
+except Exception as e:
+    MediLink_ConfigLoader.log("Unexpected error accessing MediBot_Preprocessor_lib: {}".format(str(e)), level="ERROR")
+    print("Error: Unexpected error with MediBot_Preprocessor_lib: {}".format(str(e)))
 
 # XP Compatibility: Add fallback function if import fails
 if load_insurance_data_from_mains is None:
@@ -30,6 +44,7 @@ if load_insurance_data_from_mains is None:
         Fallback function for load_insurance_data_from_mains when MediBot_Preprocessor_lib is not available.
         Returns empty dictionary to prevent AttributeError.
         """
+        MediLink_ConfigLoader.log("Using fallback load_insurance_data_from_mains function", level="WARNING")
         print("Warning: load_insurance_data_from_mains not available. Using empty insurance mapping.")
         return {}
     
@@ -83,9 +98,17 @@ except ImportError:
         update_crosswalk_with_new_payer_id = None
 
 # Import enhanced insurance selection with fallback
+# XP/Python34 Compatibility: Enhanced error handling with verbose output
 try:
     from MediLink_insurance_utils import safe_insurance_type_selection
-except ImportError:
+    MediLink_ConfigLoader.log("Successfully imported safe_insurance_type_selection from MediLink_insurance_utils", level="DEBUG")
+except ImportError as e:
+    MediLink_ConfigLoader.log("ImportError importing safe_insurance_type_selection: {}".format(str(e)), level="WARNING")
+    print("Warning: safe_insurance_type_selection not available: {}".format(str(e)))
+    safe_insurance_type_selection = None
+except Exception as e:
+    MediLink_ConfigLoader.log("Unexpected error importing safe_insurance_type_selection: {}".format(str(e)), level="ERROR")
+    print("Error: Unexpected error importing safe_insurance_type_selection: {}".format(str(e)))
     safe_insurance_type_selection = None
 
 # Import display utilities

MediLink/MediLink_PatientProcessor.py

@@ -17,16 +17,43 @@ if project_dir not in sys.path:
     sys.path.append(project_dir)
 
 # Use dynamic import to avoid circular dependencies
+# XP/Python34 Compatibility: Enhanced error handling with verbose output
 def _get_load_insurance_function():
     """Dynamically import load_insurance_data_from_mains to avoid circular imports."""
     try:
         import MediBot_Preprocessor_lib
-        return MediBot_Preprocessor_lib.load_insurance_data_from_mains
-    except (ImportError, AttributeError) as e:
         if MediLink_ConfigLoader and hasattr(MediLink_ConfigLoader, 'log'):
-            MediLink_ConfigLoader.log("Failed to import load_insurance_data_from_mains: {}".format(e), level="WARNING")
+            MediLink_ConfigLoader.log("Successfully imported MediBot_Preprocessor_lib", level="DEBUG")
+        
+        if hasattr(MediBot_Preprocessor_lib, 'load_insurance_data_from_mains'):
+            func = MediBot_Preprocessor_lib.load_insurance_data_from_mains
+            if MediLink_ConfigLoader and hasattr(MediLink_ConfigLoader, 'log'):
+                MediLink_ConfigLoader.log("Successfully accessed load_insurance_data_from_mains function", level="DEBUG")
+            return func
         else:
-            print("Warning: Failed to import load_insurance_data_from_mains: {}".format(e))
+            error_msg = "MediBot_Preprocessor_lib imported but load_insurance_data_from_mains attribute missing"
+            if MediLink_ConfigLoader and hasattr(MediLink_ConfigLoader, 'log'):
+                MediLink_ConfigLoader.log(error_msg, level="WARNING")
+            print("Warning: {}".format(error_msg))
+            return None
+            
+    except ImportError as e:
+        error_msg = "ImportError accessing MediBot_Preprocessor_lib: {}".format(str(e))
+        if MediLink_ConfigLoader and hasattr(MediLink_ConfigLoader, 'log'):
+            MediLink_ConfigLoader.log(error_msg, level="WARNING")
+        print("Warning: {}".format(error_msg))
+        return None
+    except AttributeError as e:
+        error_msg = "AttributeError accessing load_insurance_data_from_mains: {}".format(str(e))
+        if MediLink_ConfigLoader and hasattr(MediLink_ConfigLoader, 'log'):
+            MediLink_ConfigLoader.log(error_msg, level="WARNING")
+        print("Warning: {}".format(error_msg))
+        return None
+    except Exception as e:
+        error_msg = "Unexpected error accessing MediBot_Preprocessor_lib: {}".format(str(e))
+        if MediLink_ConfigLoader and hasattr(MediLink_ConfigLoader, 'log'):
+            MediLink_ConfigLoader.log(error_msg, level="ERROR")
+        print("Error: {}".format(error_msg))
         return None
 
 load_insurance_data_from_mains = _get_load_insurance_function()
@@ -109,6 +136,7 @@ def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_map
     # Enhanced mode check with graceful degradation
     enhanced_mode = False
     
+    # XP/Python34 Compatibility: Enhanced error handling with verbose output
     try:
         from MediLink_insurance_utils import (
             get_feature_flag, 
@@ -118,9 +146,11 @@ def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_map
         MediLink_ConfigLoader.log("Insurance enhancement utilities loaded successfully", level="DEBUG")
     except ImportError as e:
         MediLink_ConfigLoader.log("Insurance utils not available: {}. Using legacy mode.".format(str(e)), level="INFO")
+        print("Info: Using legacy insurance processing mode due to: {}".format(str(e)))
         enhanced_mode = False
     except Exception as e:
         MediLink_ConfigLoader.log("Error initializing insurance enhancements: {}. Using legacy mode.".format(str(e)), level="ERROR")
+        print("Warning: Insurance enhancement error ({}), using legacy mode".format(str(e)))
         enhanced_mode = False
     
     if patient_insurance_type_mapping is None:

{medicafe-0.250806.12.dist-info → medicafe-0.250806.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: medicafe
-Version: 0.250806.12
+Version: 0.250806.14
 Summary: MediCafe
 Home-page: https://github.com/katanada2
 Author: Daniel Vidaud

{medicafe-0.250806.12.dist-info → medicafe-0.250806.14.dist-info}/RECORD

@@ -1,8 +1,8 @@
-MediBot/MediBot.bat,sha256=Ois6hLLYurDI-mXaRseyrlgUy6J4PpP1nIW5g0Rda3E,30030
+MediBot/MediBot.bat,sha256=FQta6duIAMLN9d4t4dFi01F2IZSJt3_7B0Md1QqSKa8,13241
 MediBot/MediBot.py,sha256=iJwaLraJYHdb_8HWP3e0do4CCx3fVB17WnRHW0Wx5yk,28879
 MediBot/MediBot_Charges.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-MediBot/MediBot_Crosswalk_Library.py,sha256=X-lo8bvT-vmCqbrKFi_ApmVI6wQs53mz1ygyVeCf1SI,23463
-MediBot/MediBot_Crosswalk_Utils.py,sha256=QIf2zZI0DVOLy23tuXhM83VrE9NDIqJlfZIlSM_zQWM,34560
+MediBot/MediBot_Crosswalk_Library.py,sha256=HZHbjKHhjLW2jERmLS6pEZOl-MUxUu1YwA6oUltfdkE,24693
+MediBot/MediBot_Crosswalk_Utils.py,sha256=Qf3O9Wh1cbfGbYqObK5rVh99qRCboWnmVUpubEZeN3A,35763
 MediBot/MediBot_Post.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediBot/MediBot_Preprocessor.py,sha256=zAcfyuE8wl9JRzLGsUnnXiHxAr-hbCCIB2M-Jb3LUqI,16203
 MediBot/MediBot_Preprocessor_lib.py,sha256=DTtsJ1FfzlERcfKvWHVzhISa1So5R_ssAqKijDjYNmw,71939
@@ -19,9 +19,9 @@ MediBot/update_medicafe.py,sha256=umeCbaLZi8K9Vgym8WNQ7A3gO1ZiJM0YYLSkSiM1HCU,23
 MediCafe/MediLink_ConfigLoader.py,sha256=J7v4-3bNfCf29DV7vTBsQ6yuWpcRRgBu4Q6_OjUETcE,7042
 MediCafe/__init__.py,sha256=6bSEXGy35ljEeTv40LcsokC8riYGk6lRj1QDpSepwnA,5461
 MediCafe/__main__.py,sha256=Sr_4BHC3_o11472EEJ9qcrfuQLTyPZJHNqTTLb1yVx8,12050
-MediCafe/api_core.py,sha256=uevBnoJJOtF_9WuJTVNkJOdNFfp9ReLlK5CtDoSdWZ4,58693
+MediCafe/api_core.py,sha256=8sSrTd1WLbPTaROkSGikqxMNyWh-UIb0MIJYzon5YpI,61149
 MediCafe/api_core_backup.py,sha256=mad-sFk4nyUmNb2nQ_t4GMT6FJ4hrdJyKHUO0oRvMaE,18629
-MediCafe/api_factory.py,sha256=GJjsJQwrAI7WY2cbn3P1I-w9wtcRmQaXMw8CtFDvkxU,11015
+MediCafe/api_factory.py,sha256=I5AeJoyu6m7oCrjc2OvVvO_4KSBRutTsR1riiWhTZV0,12086
 MediCafe/api_utils.py,sha256=KWQB0q1k5E6frOFFlKWcFpHNcqfrS7KJ_82672wbupw,14041
 MediCafe/core_utils.py,sha256=VtNtEwBDhjJjQQJJrW90nkU7TFynqYmDXfk29lnV_h4,15821
 MediCafe/graphql_utils.py,sha256=5i_pNCNRUXox2v5zraPzUw4n7rUt9ZEAkLqVa59LWAc,45713
@@ -33,7 +33,7 @@ MediLink/MediLink.py,sha256=p91MYghOCbNf3ikTzm5P9V1Luj035yd83EDbQ-Ov6oM,33258
 MediLink/MediLink_277_decoder.py,sha256=Z3hQK2j-YzdXjov6aDlDRc7M_auFBnl3se4OF5q6_04,4358
 MediLink/MediLink_837p_cob_library.py,sha256=sK43fwq-arTUyrwbYWfJIhwW6aemXmpS2F1kfXFPe9I,29851
 MediLink/MediLink_837p_encoder.py,sha256=O2HWuBbFpe4qsK5bKZF3LDJRSHGGsdiPyr_sJ8s4Bz4,28897
-MediLink/MediLink_837p_encoder_library.py,sha256=RXgeoZ2A83VUq0UZYGtvh2OfRmMddZRbxVcCaSw0wcM,62673
+MediLink/MediLink_837p_encoder_library.py,sha256=Q5MCcw-XWM0pLSFWxIuw4AYGR77_fefPR5nsdK0z-b8,64712
 MediLink/MediLink_837p_utilities.py,sha256=uWIubJOw6PPidAfNx8hH47ecyXYJLr5b6xQvqKCvQ4A,15884
 MediLink/MediLink_API_Generator.py,sha256=UUml-PBU3BQduun8RzFH4zfUuo6-p5Ufg7b6Vic-VrY,11171
 MediLink/MediLink_API_v2.py,sha256=mcIgLnXPS_NaUBrkKJ8mxCUaQ0AuQUeU1vG6DoplbVY,7733
@@ -53,7 +53,7 @@ MediLink/MediLink_Gmail.py,sha256=Wl8g9D-CpsBpmyvAAErL7T327RYy_sRR2gY3SHJbNx8,35
 MediLink/MediLink_GraphQL.py,sha256=O6OCaumT0zIC7YcIAwLOOYxiQnYhoMc48UL8ilNIBec,45720
 MediLink/MediLink_Mailer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediLink/MediLink_Parser.py,sha256=w2ZD4minjwkaMz7nzP_r8v_Ow_uM5KHjpPSY8mIHcdE,9787
-MediLink/MediLink_PatientProcessor.py,sha256=rYMoUp2LvZxD3BtmoDChonwH9zep3C6fYhBTPwww47g,14871
+MediLink/MediLink_PatientProcessor.py,sha256=No094ZlRkxvo9pPJCcjgR-mZK1vi8PeHoaS2EmgWtd4,16715
 MediLink/MediLink_Scan.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediLink/MediLink_Scheduler.py,sha256=UJvxhDvHraqra2_TlQVlGeh5jRFrrfK6nCVUHnKOEMY,38
 MediLink/MediLink_StatusCheck.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -73,9 +73,9 @@ MediLink/test_cob_library.py,sha256=wUMv0-Y6fNsKcAs8Z9LwfmEBRO7oBzBAfWmmzwoNd1g,
 MediLink/test_timing.py,sha256=yH2b8QPLDlp1Zy5AhgtjzjnDHNGhAD16ZtXtZzzESZw,2042
 MediLink/test_validation.py,sha256=FJrfdUFK--xRScIzrHCg1JeGdm0uJEoRnq6CgkP2lwM,4154
 MediLink/webapp.html,sha256=JPKT559aFVBi1r42Hz7C77Jj0teZZRumPhBev8eSOLk,19806
-medicafe-0.250806.12.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
-medicafe-0.250806.12.dist-info/METADATA,sha256=VCcKck7bzDTbkDtliSUXbst4ss2tt5Pj42Q_1yjhdww,5502
-medicafe-0.250806.12.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-medicafe-0.250806.12.dist-info/entry_points.txt,sha256=m3RBUBjr-xRwEkKJ5W4a7NlqHZP_1rllGtjZnrRqKe8,52
-medicafe-0.250806.12.dist-info/top_level.txt,sha256=U6-WBJ9RCEjyIs0BlzbQq_PwedCp_IV9n1616NNV5zA,26
-medicafe-0.250806.12.dist-info/RECORD,,
+medicafe-0.250806.14.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
+medicafe-0.250806.14.dist-info/METADATA,sha256=0qLSzoyPg4j_V2Ne19ifaDyYIdG_DFOQVpQZDJm1ACw,5502
+medicafe-0.250806.14.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+medicafe-0.250806.14.dist-info/entry_points.txt,sha256=m3RBUBjr-xRwEkKJ5W4a7NlqHZP_1rllGtjZnrRqKe8,52
+medicafe-0.250806.14.dist-info/top_level.txt,sha256=U6-WBJ9RCEjyIs0BlzbQq_PwedCp_IV9n1616NNV5zA,26
+medicafe-0.250806.14.dist-info/RECORD,,