medicafe 0.250810.7__py3-none-any.whl → 0.250811.0__py3-none-any.whl

MediBot/MediBot_UI.py

@@ -45,7 +45,13 @@ class AppControl:
         # PERFORMANCE FIX: Add configuration caching to reduce lookup overhead
         self._config_cache = {}  # Cache for Medicare vs Private configuration lookups
         # Load initial paths from config when instance is created
-        self.load_paths_from_config()
+        try:
+            self.load_paths_from_config()
+        except Exception:
+            # Defer configuration loading until first access if config is unavailable
+            self._deferred_load = True
+        else:
+            self._deferred_load = False
 
     def get_pause_status(self):
         return self.script_paused
@@ -91,8 +97,29 @@ class AppControl:
         self.mapat_med_path = cached['mapat_path']
         self.medisoft_shortcut = cached['shortcut']
 
-app_control = AppControl()
-
+def _get_app_control():
+    global app_control
+    try:
+        ac = app_control
+    except NameError:
+        ac = None
+    if ac is None:
+        ac = AppControl()
+    # If deferred, attempt first load now
+    try:
+        if getattr(ac, '_deferred_load', False):
+            ac.load_paths_from_config()
+            ac._deferred_load = False
+    except Exception:
+        pass
+    globals()['app_control'] = ac
+    return ac
+
+# Lazily initialize app_control to avoid config load at import time
+try:
+    app_control
+except NameError:
+    app_control = None
 
 
 def is_key_pressed(key_code):
@@ -105,15 +132,16 @@ def manage_script_pause(csv_data, error_message, reverse_mapping):
     user_action = 0 # initialize as 'continue'
     VK_END, VK_PAUSE = _get_vk_codes()
     
-    if not app_control.get_pause_status() and is_key_pressed(VK_PAUSE):
-        app_control.set_pause_status(True)
+    ac = _get_app_control()
+    if not ac.get_pause_status() and is_key_pressed(VK_PAUSE):
+        ac.set_pause_status(True)
         print("Script paused. Opening menu...")
         interaction_mode = 'normal'  # Assuming normal interaction mode for script pause
         user_action = user_interaction(csv_data, interaction_mode, error_message, reverse_mapping)
     
-    while app_control.get_pause_status():
+    while ac.get_pause_status():
         if is_key_pressed(VK_END):
-            app_control.set_pause_status(False)
+            ac.set_pause_status(False)
             print("Continuing...")
         elif is_key_pressed(VK_PAUSE):
             user_action = user_interaction(csv_data, 'normal', error_message, reverse_mapping)

MediCafe/MediLink_ConfigLoader.py

@@ -105,13 +105,13 @@ def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..',
         sys.exit(1)  # Exit the script due to a critical error in configuration loading
     except FileNotFoundError:
         print("One or both configuration files not found. Config: {}, Crosswalk: {}".format(config_path, crosswalk_path))
-        sys.exit(1)  # Exit the script due to a critical error in configuration loading
+        raise
     except KeyError as e:
         print("Critical configuration is missing: {}".format(e))
-        sys.exit(1)  # Exit the script due to a critical error in configuration loading
+        raise
     except Exception as e:
         print("An unexpected error occurred while loading the configuration: {}".format(e))
-        sys.exit(1)  # Exit the script due to a critical error in configuration loading
+        raise
 
 def clear_config_cache():
     """Clear the configuration cache to force reloading on next call."""
@@ -124,14 +124,23 @@ def log(message, config=None, level="INFO", error_type=None, claim=None, verbose
     
     # If config is not provided, use cached config or load it
     if config is None:
-        if _CONFIG_CACHE is None:
-            config, _ = load_configuration()
-        else:
-            config = _CONFIG_CACHE
+        try:
+            if _CONFIG_CACHE is None:
+                config, _ = load_configuration()
+            else:
+                config = _CONFIG_CACHE
+        except BaseException:
+            # Configuration unavailable; fall back to minimal console logging
+            config = {}
     
     # Setup logger if not already configured
     if not logging.root.handlers:
-        local_storage_path = config['MediLink_Config'].get('local_storage_path', '.') if isinstance(config, dict) else '.'
+        local_storage_path = '.'
+        if isinstance(config, dict):
+            try:
+                local_storage_path = config.get('MediLink_Config', {}).get('local_storage_path', '.')
+            except Exception:
+                local_storage_path = '.'
         log_filename = datetime.now().strftime("Log_%m%d%Y.log")
         log_filepath = os.path.join(local_storage_path, log_filename)
         
@@ -141,12 +150,15 @@ def log(message, config=None, level="INFO", error_type=None, claim=None, verbose
         # Create formatter
         formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
         
-        # Create file handler
-        file_handler = logging.FileHandler(log_filepath, mode='a')
-        file_handler.setFormatter(formatter)
-        
-        # Create handlers list - always include file handler
-        handlers = [file_handler]
+        handlers = []
+        try:
+            # Create file handler when path is usable
+            file_handler = logging.FileHandler(log_filepath, mode='a')
+            file_handler.setFormatter(formatter)
+            handlers.append(file_handler)
+        except Exception:
+            # Fall back to console-only if file handler cannot be created
+            pass
         
         # Add console handler only if console_output is True
         if console_output:
@@ -154,7 +166,12 @@ def log(message, config=None, level="INFO", error_type=None, claim=None, verbose
             console_handler.setFormatter(formatter)
             handlers.append(console_handler)
         
-        # Configure root logger
+        # If no handlers could be added (e.g., file path invalid and console_output False), add a console handler
+        if not handlers:
+            console_handler = logging.StreamHandler()
+            console_handler.setFormatter(formatter)
+            handlers.append(console_handler)
+        
         logging.basicConfig(level=logging_level, handlers=handlers)
     
     # Prepare log message

MediCafe/core_utils.py

@@ -513,16 +513,17 @@ def get_api_client_factory():
         config_loader = get_shared_config_loader()
         if config_loader:
             try:
+                # Be resilient to SystemExit raised inside loaders
                 config, _ = config_loader.load_configuration()
-                factory_config = config.get('API_Factory_Config', {})
+                factory_config = config.get('API_Factory_Config', {}) if isinstance(config, dict) else {}
                 return APIClientFactory(factory_config)
-            except Exception:
-                # Fall back to default configuration
+            except BaseException:
+                # Fall back to default configuration on any loader failure (including SystemExit)
                 return APIClientFactory()
         else:
             return APIClientFactory()
-    except Exception as e:
-        # Don't log error here - just return None silently
+    except BaseException:
+        # Do not allow API client factory acquisition to crash callers during import time
         return None
 
 def get_api_client(**kwargs):
@@ -555,4 +556,154 @@ def get_api_core_client(**kwargs):
         return APIClient(**kwargs)
     except ImportError:
         # Don't log error here - just return None silently
-        return None
+        return None
+
+# --- Compatibility & Process Utilities (Python 3.4.4 / Windows XP friendly) ---
+
+def is_python_34_compatible(version_info=None):
+    """
+    Return True if the interpreter is Python 3.4.4+ (as required in XP env).
+    This consolidates scattered version checks into a single function so
+    call sites remain concise and intention-revealing.
+    """
+    try:
+        if version_info is None:
+            version_info = sys.version_info
+        major = getattr(version_info, 'major', version_info[0])
+        minor = getattr(version_info, 'minor', version_info[1])
+        micro = getattr(version_info, 'micro', version_info[2])
+        return (major, minor, micro) >= (3, 4, 4)
+    except Exception:
+        # Be conservative if we cannot determine
+        return False
+
+def format_py34(template, *args, **kwargs):
+    """
+    Safe stand-in for f-strings (not available in Python 3.4).
+    Centralized to avoid ad-hoc "format_string" helpers scattered around.
+    """
+    try:
+        return template.format(*args, **kwargs)
+    except Exception:
+        # If formatting fails, return template unmodified to avoid crashes
+        return template
+
+def _decode_bytes(data, encoding_list=None):
+    """
+    Decode bytes to text using a tolerant strategy.
+    We avoid relying on platform defaults (XP may vary) and try multiple
+    encodings to reduce boilerplate at call sites.
+    """
+    if data is None:
+        return ''
+    if isinstance(data, str):
+        return data
+    if encoding_list is None:
+        encoding_list = ['utf-8', 'latin-1', 'ascii']
+    for enc in encoding_list:
+        try:
+            return data.decode(enc, 'ignore')
+        except Exception:
+            continue
+    # Last resort: str() on bytes
+    try:
+        return str(data)
+    except Exception:
+        return ''
+
+def run_cmd(cmd, timeout=None, input_text=None, shell=False, cwd=None, env=None):
+    """
+    Cross-version subprocess runner for Python 3.4/XP environments.
+    - Uses subprocess.Popen (subprocess.run is 3.5+)
+    - Returns (returncode, stdout_text, stderr_text)
+    - Accepts optional timeout (best-effort with polling for 3.4)
+    - Accepts optional input_text (string) which will be encoded to bytes
+    This consolidates repetitive Popen/communicate/decode blocks.
+    """
+    import subprocess
+    try:
+        # Prepare stdin if input is provided
+        stdin_pipe = subprocess.PIPE if input_text is not None else None
+        p = subprocess.Popen(
+            cmd,
+            stdin=stdin_pipe,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            shell=shell,
+            cwd=cwd,
+            env=env
+        )
+        if timeout is None:
+            out_bytes, err_bytes = p.communicate(
+                input=input_text.encode('utf-8') if isinstance(input_text, str) else input_text
+            )
+            return p.returncode, _decode_bytes(out_bytes), _decode_bytes(err_bytes)
+        # Implement simple timeout loop compatible with 3.4
+        import time
+        start_time = time.time()
+        while True:
+            if p.poll() is not None:
+                out_bytes, err_bytes = p.communicate()
+                return p.returncode, _decode_bytes(out_bytes), _decode_bytes(err_bytes)
+            if time.time() - start_time > timeout:
+                try:
+                    p.kill()
+                except Exception:
+                    try:
+                        p.terminate()
+                    except Exception:
+                        pass
+                out_bytes, err_bytes = p.communicate()
+                return 124, _decode_bytes(out_bytes), _decode_bytes(err_bytes)
+            time.sleep(0.05)
+    except Exception as e:
+        # Standardize failure surface
+        return 1, '', str(e)
+
+def file_is_ascii(file_path):
+    """
+    Return True if the given file can be read as ASCII-only.
+    Consolidates repeated try/open/decode blocks into one helper.
+    """
+    try:
+        if not os.path.exists(file_path):
+            return False
+        # Use strict ASCII to detect any non-ASCII characters
+        f = open(file_path, 'r')
+        try:
+            # Explicit codec arg not supported in some XP Python builds for text mode
+            # so we emulate by checking ordinals while reading
+            data = f.read()
+        finally:
+            try:
+                f.close()
+            except Exception:
+                pass
+        try:
+            data.encode('ascii')
+            return True
+        except Exception:
+            return False
+    except Exception:
+        return False
+
+def check_ascii_files(paths):
+    """
+    Given a list of paths (absolute or relative), return a list of those that
+    contain non-ASCII characters or could not be checked. This replaces
+    duplicated loops in various verification scripts.
+    """
+    problematic = []
+    try:
+        for p in paths:
+            # Normalize relative to current working directory for consistency
+            if not os.path.isabs(p):
+                abs_p = os.path.abspath(p)
+            else:
+                abs_p = p
+            if not file_is_ascii(abs_p):
+                problematic.append(p)
+    except Exception:
+        # If a failure occurs mid-scan, return what we have so far
+        return problematic
+    return problematic

MediLink/MediLink_Gmail.py

@@ -16,6 +16,20 @@ setup_python_path()
 
 from MediCafe.core_utils import get_shared_config_loader
 
+# New helpers
+from MediLink.gmail_oauth_utils import (
+    get_authorization_url as oauth_get_authorization_url,
+    exchange_code_for_token as oauth_exchange_code_for_token,
+    refresh_access_token as oauth_refresh_access_token,
+    is_valid_authorization_code as oauth_is_valid_authorization_code,
+    clear_token_cache as oauth_clear_token_cache,
+)
+from MediLink.gmail_http_utils import (
+    generate_self_signed_cert as http_generate_self_signed_cert,
+    start_https_server as http_start_https_server,
+    inspect_token as http_inspect_token,
+)
+
 # Get shared config loader
 MediLink_ConfigLoader = get_shared_config_loader()
 if MediLink_ConfigLoader:
@@ -94,77 +108,29 @@ log("Using CREDENTIALS_PATH: {}".format(CREDENTIALS_PATH), config, level="INFO")
 REDIRECT_URI = 'https://127.0.0.1:8000'
 
 def get_authorization_url():
-    with open(CREDENTIALS_PATH, 'r') as credentials_file:
-        credentials = json.load(credentials_file)
-    client_id = credentials['web']['client_id']
-    auth_url = (
-        "https://accounts.google.com/o/oauth2/v2/auth?"
-        "response_type=code&"
-        "client_id={}&"
-        "redirect_uri={}&"
-        "scope={}&"
-        "access_type=offline&"  # Requesting offline access allows the application to obtain a refresh token, enabling it to access resources even when the user is not actively using the app. This is useful for long-lived sessions.
-        # To improve user experience, consider changing this to 'online' if you don't need offline access:
-        # "access_type=online&"  # Use this if you only need access while the user is actively using the app and don't require a refresh token.
-        
-        "prompt=consent"  # This forces the user to re-consent to the requested scopes every time they authenticate. While this is useful for ensuring the user is aware of the permissions being granted, it can be modified to 'none' or omitted entirely if the application is functioning correctly and tokens are being refreshed properly.
-        # To improve user experience, consider changing this to 'none' if you want to avoid showing the consent screen every time:
-        # "prompt=none"  # Use this if you want to skip the consent screen for users who have already granted permissions.
-        # Alternatively, you can omit the prompt parameter entirely to use the default behavior:
-        # # "prompt="  # Omitting this will show the consent screen only when necessary.
-    ).format(client_id, REDIRECT_URI, SCOPES)
-    log("Generated authorization URL: {}".format(auth_url))
-    return auth_url
+    return oauth_get_authorization_url(CREDENTIALS_PATH, REDIRECT_URI, SCOPES, log)
 
 def exchange_code_for_token(auth_code, retries=3):
-    for attempt in range(retries):
-        try:
-            with open(CREDENTIALS_PATH, 'r') as credentials_file:
-                credentials = json.load(credentials_file)
-            token_url = "https://oauth2.googleapis.com/token"
-            data = {
-                'code': auth_code,
-                'client_id': credentials['web']['client_id'],
-                'client_secret': credentials['web']['client_secret'],
-                'redirect_uri': REDIRECT_URI,
-                'grant_type': 'authorization_code'
-            }
-            response = requests.post(token_url, data=data)
-            log("Token exchange response: Status code {}, Body: {}".format(response.status_code, response.text))
-            token_response = response.json()
-            if response.status_code == 200:
-                token_response['token_time'] = time.time()
-                return token_response
-            else:
-                log("Token exchange failed: {}".format(token_response))
-                if attempt < retries - 1:
-                    log("Retrying token exchange... (Attempt {}/{})".format(attempt + 1, retries))
-        except Exception as e:
-            log("Error during token exchange: {}".format(e))
-    return {}
+    return oauth_exchange_code_for_token(auth_code, CREDENTIALS_PATH, REDIRECT_URI, log, retries=retries)
 
 def get_access_token():
     if os.path.exists(TOKEN_PATH):
         with open(TOKEN_PATH, 'r') as token_file:
             token_data = json.load(token_file)
             log("Loaded token data:\n {}".format(token_data))
-            
             if 'access_token' in token_data and 'expires_in' in token_data:
                 try:
-                    # Use current time if 'token_time' is missing
                     token_time = token_data.get('token_time', time.time())
                     token_expiry_time = token_time + token_data['expires_in']
-                
                 except KeyError as e:
                     log("KeyError while accessing token data: {}".format(e))
                     return None
-                
                 if token_expiry_time > time.time():
                     log("Access token is still valid. Expires in {} seconds.".format(token_expiry_time - time.time()))
                     return token_data['access_token']
                 else:
                     log("Access token has expired. Current time: {}, Expiry time: {}".format(time.time(), token_expiry_time))
-                    new_token_data = refresh_access_token(token_data.get('refresh_token'))
+                    new_token_data = oauth_refresh_access_token(token_data.get('refresh_token'), CREDENTIALS_PATH, log)
                     if 'access_token' in new_token_data:
                         new_token_data['token_time'] = time.time()
                         with open(TOKEN_PATH, 'w') as token_file:
@@ -178,44 +144,20 @@ def get_access_token():
     return None
 
 def refresh_access_token(refresh_token):
-    log("Refreshing access token.")
-    with open(CREDENTIALS_PATH, 'r') as credentials_file:
-        credentials = json.load(credentials_file)
-    token_url = "https://oauth2.googleapis.com/token"
-    data = {
-        'client_id': credentials['web']['client_id'],
-        'client_secret': credentials['web']['client_secret'],
-        'refresh_token': refresh_token,
-        'grant_type': 'refresh_token'
-    }
-    response = requests.post(token_url, data=data)
-    log("Refresh token response: Status code {}, Body:\n {}".format(response.status_code, response.text))
-    if response.status_code == 200:
-        log("Access token refreshed successfully.")
-        return response.json()
-    else:
-        log("Failed to refresh access token. Status code: {}".format(response.status_code))
-        return {}
+    return oauth_refresh_access_token(refresh_token, CREDENTIALS_PATH, log)
 
 def bring_window_to_foreground():
     """Brings the current window to the foreground on Windows."""
     try:
         if platform.system() == 'Windows':
-            # Get the current process ID
             pid = os.getpid()
-            # Get the window handle for the current process
             hwnd = ctypes.windll.user32.GetForegroundWindow()
-            # Get the process ID of the window
             current_pid = ctypes.c_ulong()
             ctypes.windll.user32.GetWindowThreadProcessId(hwnd, ctypes.byref(current_pid))
-            
-            # If the window is not ours, try to bring it to front
             if current_pid.value != pid:
-                # Try to set the window to foreground
                 ctypes.windll.user32.SetForegroundWindow(hwnd)
-                # If that fails, try the alternative method
                 if ctypes.windll.user32.GetForegroundWindow() != hwnd:
-                    ctypes.windll.user32.ShowWindow(hwnd, 9)  # SW_RESTORE = 9
+                    ctypes.windll.user32.ShowWindow(hwnd, 9)
                     ctypes.windll.user32.SetForegroundWindow(hwnd)
     except Exception as e:
         log("Error bringing window to foreground: {}".format(e))
@@ -238,22 +180,17 @@ class RequestHandler(BaseHTTPRequestHandler):
             post_data = self.rfile.read(content_length)
             data = json.loads(post_data.decode('utf-8'))
             links = data.get('links', [])
-
-            # Log the content of links
             log("Received links: {}".format(links))
-
             file_ids = [link.get('fileId', None) for link in links if link.get('fileId')]
             log("File IDs received from client: {}".format(file_ids))
-            
-            # Proceed with downloading files
             download_docx_files(links)
             self.send_response(200)
-            self._set_headers()  # Include CORS headers
+            self._set_headers()
             self.end_headers()
             response = json.dumps({"status": "success", "message": "All files downloaded", "fileIds": file_ids})
             self.wfile.write(response.encode('utf-8'))
             shutdown_event.set()
-            bring_window_to_foreground()  # Bring window to foreground after download
+            bring_window_to_foreground()
         elif self.path == '/shutdown':
             log("Shutdown request received.")
             self.send_response(200)
@@ -261,14 +198,13 @@ class RequestHandler(BaseHTTPRequestHandler):
             self.end_headers()
             response = json.dumps({"status": "success", "message": "Server is shutting down."})
             self.wfile.write(response.encode('utf-8'))
-            shutdown_event.set()  # Signal shutdown event instead of calling stop_server directly
+            shutdown_event.set()
         elif self.path == '/delete-files':
             content_length = int(self.headers['Content-Length'])
             post_data = self.rfile.read(content_length)
             data = json.loads(post_data.decode('utf-8'))
             file_ids = data.get('fileIds', [])
             log("File IDs to delete received from client: {}".format(file_ids))
-            
             if not isinstance(file_ids, list):
                 self.send_response(400)
                 self._set_headers()
@@ -276,9 +212,8 @@ class RequestHandler(BaseHTTPRequestHandler):
                 response = json.dumps({"status": "error", "message": "Invalid fileIds parameter."})
                 self.wfile.write(response.encode('utf-8'))
                 return
-            
             self.send_response(200)
-            self._set_headers()  # Include CORS headers
+            self._set_headers()
             self.end_headers()
             response = json.dumps({"status": "success", "message": "Files deleted successfully."})
             self.wfile.write(response.encode('utf-8'))
@@ -287,23 +222,21 @@ class RequestHandler(BaseHTTPRequestHandler):
             self.end_headers()
 
     def do_GET(self):
-        log("Full request path: {}".format(self.path))  # Log the full path for debugging
+        log("Full request path: {}".format(self.path))
         if self.path.startswith("/?code="):
             auth_code = self.path.split('=')[1].split('&')[0]
-            auth_code = requests.utils.unquote(auth_code)  # Decode if URL-encoded
+            auth_code = requests.utils.unquote(auth_code)
             log("Received authorization code: {}".format(auth_code))
-            if is_valid_authorization_code(auth_code):
+            if oauth_is_valid_authorization_code(auth_code, log):
                 try:
                     token_response = exchange_code_for_token(auth_code)
                     if 'access_token' not in token_response:
-                        # Check for specific error message
                         if token_response.get("status") == "error":
                             self.send_response(400)
                             self.send_header('Content-type', 'text/html')
                             self.end_headers()
                             self.wfile.write(token_response["message"].encode())
                             return
-                        # Handle other cases
                         raise ValueError("Access token not found in response.")
                 except Exception as e:
                     log("Error during token exchange: {}".format(e))
@@ -312,7 +245,7 @@ class RequestHandler(BaseHTTPRequestHandler):
                     self.end_headers()
                     self.wfile.write("An error occurred during authentication. Please try again.".encode())
                 else:
-                    log("Token response: {}".format(token_response))  # Add this line
+                    log("Token response: {}".format(token_response))
                     if 'access_token' in token_response:
                         with open(TOKEN_PATH, 'w') as token_file:
                             json.dump(token_response, token_file)
@@ -320,34 +253,31 @@ class RequestHandler(BaseHTTPRequestHandler):
                         self.send_header('Content-type', 'text/html')
                         self.end_headers()
                         self.wfile.write("Authentication successful. You can close this window now.".encode())
-                        initiate_link_retrieval(config)  # Pass config here
+                        initiate_link_retrieval(config)
                     else:
-                        log("Authentication failed with response: {}".format(token_response))  # Log the full response
+                        log("Authentication failed with response: {}".format(token_response))
                         if 'error' in token_response:
                             error_description = token_response.get('error_description', 'No description provided.')
-                            log("Error details: {}".format(error_description))  # Log specific error details
-
-                        # Provide user feedback based on the error
+                            log("Error details: {}".format(error_description))
                         if token_response.get('error') == 'invalid_grant':
                             log("Invalid grant error encountered. Authorization code: {}, Response: {}".format(auth_code, token_response))
                             check_invalid_grant_causes(auth_code)
-                            clear_token_cache()  # Clear the cache on invalid grant
+                            oauth_clear_token_cache(TOKEN_PATH, log)
                             user_message = "Authentication failed: Invalid or expired authorization code. Please try again."
                         else:
                             user_message = "Authentication failed. Please check the logs for more details."
-
                         self.send_response(400)
                         self.send_header('Content-type', 'text/html')
                         self.end_headers()
                         self.wfile.write(user_message.encode())
-                        shutdown_event.set()  # Signal shutdown event after failed authentication
+                        shutdown_event.set()
             else:
                 log("Invalid authorization code format: {}".format(auth_code))
                 self.send_response(400)
                 self.send_header('Content-type', 'text/html')
                 self.end_headers()
                 self.wfile.write("Invalid authorization code format. Please try again.".encode())
-                shutdown_event.set()  # Signal shutdown event after failed authentication
+                shutdown_event.set()
         elif self.path == '/downloaded-emails':
             self.send_response(200)
             self._set_headers()
@@ -365,75 +295,17 @@ class RequestHandler(BaseHTTPRequestHandler):
             self.wfile.write(b'HTTPS server is running.')
 
 def generate_self_signed_cert(cert_file, key_file):
-    log("Checking if certificate file exists: " + cert_file)
-    log("Checking if key file exists: " + key_file)
-    
-    # Check if certificate exists and is not expired
-    cert_needs_regeneration = True
-    if os.path.exists(cert_file):
-        try:
-            # Check certificate expiration
-            check_cmd = ['openssl', 'x509', '-in', cert_file, '-checkend', '86400', '-noout']  # Check if expires in next 24 hours
-            result = subprocess.call(check_cmd)
-            if result == 0:
-                log("Certificate is still valid")
-                cert_needs_regeneration = False
-            else:
-                log("Certificate is expired or will expire soon")
-                # Delete expired certificate and key files
-                try:
-                    if os.path.exists(cert_file):
-                        os.remove(cert_file)
-                        log("Deleted expired certificate file: {}".format(cert_file))
-                    if os.path.exists(key_file):
-                        os.remove(key_file)
-                        log("Deleted expired key file: {}".format(key_file))
-                except Exception as e:
-                    log("Error deleting expired certificate files: {}".format(e))
-        except Exception as e:
-            log("Error checking certificate expiration: {}".format(e))
-    
-    if cert_needs_regeneration:
-        log("Generating self-signed SSL certificate...")
-        cmd = [
-            'openssl', 'req', '-config', openssl_cnf, '-nodes', '-new', '-x509',
-            '-keyout', key_file,
-            '-out', cert_file,
-            '-days', '365',
-            '-sha256'  # Use SHA-256 for better security
-            #'-subj', '/C=US/ST=...' The openssl.cnf file contains default values for these fields, but they can be overridden by the -subj option.
-        ]
-        try:
-            log("Running command: " + ' '.join(cmd))
-            result = subprocess.call(cmd)
-            log("Command finished with result: " + str(result))
-            if result != 0:
-                raise RuntimeError("Failed to generate self-signed certificate")
-            
-            # Verify the certificate was generated correctly
-            verify_cmd = ['openssl', 'x509', '-in', cert_file, '-text', '-noout']
-            verify_result = subprocess.call(verify_cmd)
-            if verify_result != 0:
-                raise RuntimeError("Generated certificate verification failed")
-                
-            log("Self-signed SSL certificate generated and verified successfully.")
-        except Exception as e:
-            log("Error generating self-signed certificate: {}".format(e))
-            raise
+    http_generate_self_signed_cert(openssl_cnf, cert_file, key_file, log, subprocess)
 
 def run_server():
     global httpd
     try:
         log("Attempting to start server on port " + str(server_port))
-        server_address = ('0.0.0.0', server_port)  # Bind to all interfaces
-        httpd = HTTPServer(server_address, RequestHandler)
-        log("Attempting to wrap socket with SSL. cert_file=" + cert_file + ", key_file=" + key_file)
-        
         if not os.path.exists(cert_file):
             log("Error: Certificate file not found: " + cert_file)
         if not os.path.exists(key_file):
             log("Error: Key file not found: " + key_file)
-        
+        httpd = HTTPServer(('0.0.0.0', server_port), RequestHandler)
         httpd.socket = ssl.wrap_socket(httpd.socket, certfile=cert_file, keyfile=key_file, server_side=True)
         log("Starting HTTPS server on port {}".format(server_port))
         httpd.serve_forever()
@@ -448,8 +320,8 @@ def stop_server():
         httpd.shutdown()
         httpd.server_close()
         log("HTTPS server stopped.")
-    shutdown_event.set()  # Signal shutdown event
-    bring_window_to_foreground()  # Bring window to foreground after shutdown
+    shutdown_event.set()
+    bring_window_to_foreground()
 
 def load_downloaded_emails():
     downloaded_emails = set()
@@ -460,86 +332,26 @@ def load_downloaded_emails():
     return downloaded_emails
 
 def download_docx_files(links):
-    # Load the set of downloaded emails
-    # TODO (LOW-MEDIUM PRIORITY - CSV File Detection and Routing):
-    # PROBLEM: Downloaded files may include CSV files that need special handling and routing.
-    # Currently all files are treated the same regardless of extension.
-    #
-    # IMPLEMENTATION REQUIREMENTS:
-    # 1. File Extension Detection:
-    #    - Check each downloaded file for .csv extension (case-insensitive)
-    #    - Also check for common CSV variants: .txt, .tsv, .dat (based on content)
-    #    - Handle files with multiple extensions like "report.csv.zip"
-    #
-    # 2. Content-Based Detection (Advanced):
-    #    - For files without clear extensions, peek at content
-    #    - Look for CSV patterns: comma-separated values, consistent column counts
-    #    - Handle Excel files that might be CSV exports (.xlsx with CSV content)
-    #
-    # 3. CSV Routing Logic:
-    #    - Move CSV files to dedicated CSV processing directory
-    #    - Maintain file naming conventions for downstream processing
-    #    - Log CSV file movements for audit trail
-    #    - Preserve original file permissions and timestamps
-    #
-    # IMPLEMENTATION STEPS:
-    # 1. Add helper function detect_csv_files(downloaded_files) -> list
-    # 2. Add helper function move_csv_to_processing_dir(csv_file, destination_dir)
-    # 3. Add configuration for CSV destination directory in config file
-    # 4. Update this function to call CSV detection and routing after download
-    # 5. Add error handling for file movement failures
-    # 6. Add logging for all CSV file operations
-    #
-    # CONFIGURATION NEEDED:
-    # - config['csv_processing_dir']: Where to move detected CSV files
-    # - config['csv_file_extensions']: List of extensions to treat as CSV
-    # - config['csv_content_detection']: Boolean to enable content-based detection
-    #
-    # ERROR HANDLING:
-    # - Handle permission errors when moving files
-    # - Handle disk space issues
-    # - Gracefully handle corrupted or locked files
-    # - Provide fallback options when CSV directory is unavailable
-    #
-    # TESTING SCENARIOS:
-    # - Mixed file types: .docx, .csv, .pdf in same download batch
-    # - CSV files with unusual extensions (.txt, .dat)
-    # - Large CSV files (>100MB)
-    # - CSV files in ZIP archives
-    #
-    # FILES TO MODIFY: This file (download_docx_files function)
-    # RELATED: May need updates to CSV processing modules that expect files in specific locations
     downloaded_emails = load_downloaded_emails()
-
     for link in links:
         try:
             url = link.get('url', '')
             filename = link.get('filename', '')
-            
-            # Log the variables to debug
             log("Processing link: url='{}', filename='{}'".format(url, filename))
-            
-            # CSV ROUTING PLACEHOLDER:
-            # - Detect CSV-like extensions before download and log the intended routing decision.
-            # - This is a no-op for now to avoid side-effects until the pipeline is verified on XP.
             lower_name = (filename or '').lower()
             looks_like_csv = any(lower_name.endswith(ext) for ext in ['.csv', '.tsv', '.txt', '.dat'])
             if looks_like_csv:
                 log("[CSV Routing Preview] Detected CSV-like filename: {}. Would route to CSV processing directory.".format(filename))
-            
-            # Skip if email already downloaded
             if filename in downloaded_emails:
                 log("Skipping already downloaded email: {}".format(filename))
                 continue
-
             log("Downloading .docx file from URL: {}".format(url))
-            response = requests.get(url, verify=False)  # Set verify to False for self-signed certs
+            response = requests.get(url, verify=False)
             if response.status_code == 200:
                 file_path = os.path.join(local_storage_path, filename)
                 with open(file_path, 'wb') as file:
                     file.write(response.content)
                 log("Downloaded .docx file: {}".format(filename))
-                # Add to the set and save the updated list
                 downloaded_emails.add(filename)
                 with open(downloaded_emails_file, 'a') as file:
                     file.write(filename + '\n')
@@ -567,59 +379,44 @@ def open_browser_with_executable(url, browser_path=None):
 
 def initiate_link_retrieval(config):
     log("Initiating browser via implicit GET.")
-    url_get = "https://script.google.com/macros/s/{}/exec?action=get_link".format(config['MediLink_Config']['webapp_deployment_id'])  # Use config here
+    url_get = "https://script.google.com/macros/s/{}/exec?action=get_link".format(config['MediLink_Config']['webapp_deployment_id'])
     open_browser_with_executable(url_get)
-    
     log("Preparing POST call.")
-    url = "https://script.google.com/macros/s/{}/exec".format(config['MediLink_Config']['webapp_deployment_id'])  # Use config here
+    url = "https://script.google.com/macros/s/{}/exec".format(config['MediLink_Config']['webapp_deployment_id'])
     downloaded_emails = list(load_downloaded_emails())
-    payload = {
-        "downloadedEmails": downloaded_emails
-    }
-
+    payload = {"downloadedEmails": downloaded_emails}
     access_token = get_access_token()
     if not access_token:
         log("Access token not found. Please authenticate first.")
-        shutdown_event.set()  # Signal shutdown event if token is not found
+        shutdown_event.set()
         return
-
-    # Inspect the token to check its validity and permissions
-    token_info = inspect_token(access_token)
+    token_info = http_inspect_token(access_token, log, delete_token_file_fn=delete_token_file, stop_server_fn=stop_server)
     if token_info is None:
         log("Access token is invalid. Please re-authenticate.")
-        shutdown_event.set()  # Signal shutdown event if token is invalid
+        shutdown_event.set()
         return
-
-    # Proceed with the rest of the function if the token is valid
-    headers = {
-        'Authorization': 'Bearer {}'.format(access_token),
-        'Content-Type': 'application/json'
-    }
-    
+    headers = {'Authorization': 'Bearer {}'.format(access_token), 'Content-Type': 'application/json'}
     log("Request headers: {}".format(headers))
     log("Request payload: {}".format(payload))
-
     handle_post_response(url, payload, headers)
-        
+
 def handle_post_response(url, payload, headers):
     try:
         response = requests.post(url, json=payload, headers=headers)
         log("Response status code: {}".format(response.status_code))
         log("Response body: {}".format(response.text))
-
         if response.status_code == 200:
             response_data = response.json()
-            log("Parsed response data: {}".format(response_data))  # Log the parsed response data
+            log("Parsed response data: {}".format(response_data))
             if response_data.get("status") == "error":
                 log("Error message from server: {}".format(response_data.get("message")))
                 print("Error: {}".format(response_data.get("message")))
-                shutdown_event.set()  # Signal shutdown event after error
+                shutdown_event.set()
             else:
                 log("Link retrieval initiated successfully.")
         elif response.status_code == 401:
             log("Unauthorized. Check if the token has the necessary scopes.Response body: {}".format(response.text))
-            # Inspect the token to log its details
-            token_info = inspect_token(headers['Authorization'].split(' ')[1])
+            token_info = http_inspect_token(headers['Authorization'].split(' ')[1], log, delete_token_file_fn=delete_token_file, stop_server_fn=stop_server)
             log("Token details: {}".format(token_info))
             shutdown_event.set()
         elif response.status_code == 403:
@@ -639,26 +436,7 @@ def handle_post_response(url, payload, headers):
         shutdown_event.set()
 
 def inspect_token(access_token):
-    info_url = "https://www.googleapis.com/oauth2/v1/tokeninfo?access_token={}".format(access_token)
-    try:
-        response = requests.get(info_url)
-        log("Token info: Status code {}, Body: {}".format(response.status_code, response.text))
-        
-        if response.status_code == 200:
-            return response.json()
-        else:
-            log("Failed to inspect token. Status code: {}, Body: {}".format(response.status_code, response.text))
-            # Check for invalid token
-            if response.status_code == 400 and "invalid_token" in response.text:
-                log("Access token is invalid. Deleting token.json and stopping the server.")
-                delete_token_file()  # Delete the token.json file
-                print("Access token is invalid. Please re-authenticate and restart the server.")
-                stop_server()  # Stop the server
-                return None  # Return None for invalid tokens
-            return None  # Return None for other invalid tokens
-    except Exception as e:
-        log("Exception during token inspection: {}".format(e))
-        return None
+    return http_inspect_token(access_token, log, delete_token_file_fn=delete_token_file, stop_server_fn=stop_server)
 
 def delete_token_file():
     try:
@@ -679,67 +457,38 @@ def auth_and_retrieval():
     access_token = get_access_token()
     if not access_token:
         log("Access token not found or expired. Please authenticate first.")
-        #print("If the browser does not open automatically, please open the following URL in your browser to authorize the application:")
         auth_url = get_authorization_url()
-        #print(auth_url)
         open_browser_with_executable(auth_url)
-        shutdown_event.wait()  # Wait for the shutdown event to be set after authentication
+        shutdown_event.wait()
     else:
         log("Access token found. Proceeding.")
-        initiate_link_retrieval(config)  # Pass config here
-        shutdown_event.wait()  # Wait for the shutdown event to be set
+        initiate_link_retrieval(config)
+        shutdown_event.wait()
 
 def is_valid_authorization_code(auth_code):
-    # Check if the authorization code is not None and is a non-empty string
-    if auth_code and isinstance(auth_code, str) and len(auth_code) > 0:  # Check for non-empty string
-        return True
-    log("Invalid authorization code format: {}".format(auth_code))
-    return False
+    return oauth_is_valid_authorization_code(auth_code, log)
 
 def clear_token_cache():
-    if os.path.exists(TOKEN_PATH):
-        os.remove(TOKEN_PATH)
-        log("Cleared token cache.")
+    oauth_clear_token_cache(TOKEN_PATH, log)
 
 def check_invalid_grant_causes(auth_code):
-    # TODO Implement this function in the future to check for common causes of invalid_grant error
-    # Log potential causes for invalid_grant
-    # XP/Network NOTE: On older systems, clock skew and reused codes are frequent causes.
     log("FUTURE IMPLEMENTATION: Checking common causes for invalid_grant error with auth code: {}".format(auth_code))
-    # Suggested checks (to be implemented when plumbing is ready):
-    # - Has authorization code already been used?
-    # - Does redirect URI exactly match the one registered (case and trailing slashes)?
-    # - Is system clock skewed? Compare to Google time; log skew if detected.
-    # - Are the requested scopes enabled for this OAuth client?
-    # - Did the user revoke access between code issuance and token exchange?
-    # Each of these would produce a specific log to speed up troubleshooting on XP.
-"""
-if is_code_used(auth_code):
-        log("Authorization code has already been used.")
-    if not is_redirect_uri_correct():
-        log("Redirect URI does not match the registered URI.")
-"""
 
 if __name__ == "__main__":
     signal.signal(signal.SIGINT, signal_handler)
     signal.signal(signal.SIGTERM, signal_handler)
-
     try:
-        # Generate SSL certificate if it doesn't exist
         generate_self_signed_cert(cert_file, key_file)
-
         from threading import Thread
         log("Starting server thread.")
         server_thread = Thread(target=run_server)
         server_thread.daemon = True
         server_thread.start()
-
         auth_and_retrieval()
-
         log("Stopping HTTPS server.")
-        stop_server()  # Ensure the server is stopped
+        stop_server()
         log("Waiting for server thread to finish.")
-        server_thread.join()  # Wait for the server thread to finish
+        server_thread.join()
     except KeyboardInterrupt:
         log("KeyboardInterrupt received, stopping server.")
         stop_server()

MediLink/gmail_http_utils.py

@@ -0,0 +1,88 @@
+import json
+import os
+import ssl
+import requests
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+
+def generate_self_signed_cert(openssl_cnf_path, cert_file, key_file, log, subprocess_module):
+    log("Checking if certificate file exists: " + cert_file)
+    log("Checking if key file exists: " + key_file)
+
+    cert_needs_regeneration = True
+    if os.path.exists(cert_file):
+        try:
+            check_cmd = ['openssl', 'x509', '-in', cert_file, '-checkend', '86400', '-noout']
+            result = subprocess_module.call(check_cmd)
+            if result == 0:
+                log("Certificate is still valid")
+                cert_needs_regeneration = False
+            else:
+                log("Certificate is expired or will expire soon")
+                try:
+                    if os.path.exists(cert_file):
+                        os.remove(cert_file)
+                        log("Deleted expired certificate file: {}".format(cert_file))
+                    if os.path.exists(key_file):
+                        os.remove(key_file)
+                        log("Deleted expired key file: {}".format(key_file))
+                except Exception as e:
+                    log("Error deleting expired certificate files: {}".format(e))
+        except Exception as e:
+            log("Error checking certificate expiration: {}".format(e))
+
+    if cert_needs_regeneration:
+        log("Generating self-signed SSL certificate...")
+        cmd = [
+            'openssl', 'req', '-config', openssl_cnf_path, '-nodes', '-new', '-x509',
+            '-keyout', key_file,
+            '-out', cert_file,
+            '-days', '365',
+            '-sha256'
+        ]
+        try:
+            log("Running command: " + ' '.join(cmd))
+            result = subprocess_module.call(cmd)
+            log("Command finished with result: " + str(result))
+            if result != 0:
+                raise RuntimeError("Failed to generate self-signed certificate")
+            verify_cmd = ['openssl', 'x509', '-in', cert_file, '-text', '-noout']
+            verify_result = subprocess_module.call(verify_cmd)
+            if verify_result != 0:
+                raise RuntimeError("Generated certificate verification failed")
+            log("Self-signed SSL certificate generated and verified successfully.")
+        except Exception as e:
+            log("Error generating self-signed certificate: {}".format(e))
+            raise
+
+
+def start_https_server(port, handler_cls, cert_file, key_file, log):
+    server_address = ('0.0.0.0', port)
+    httpd = HTTPServer(server_address, handler_cls)
+    log("Attempting to wrap socket with SSL. cert_file=" + cert_file + ", key_file=" + key_file)
+    httpd.socket = ssl.wrap_socket(httpd.socket, certfile=cert_file, keyfile=key_file, server_side=True)
+    log("Starting HTTPS server on port {}".format(port))
+    httpd.serve_forever()
+    return httpd
+
+
+def inspect_token(access_token, log, delete_token_file_fn=None, stop_server_fn=None):
+    info_url = "https://www.googleapis.com/oauth2/v1/tokeninfo?access_token={}".format(access_token)
+    try:
+        response = requests.get(info_url)
+        log("Token info: Status code {}, Body: {}".format(response.status_code, response.text))
+        if response.status_code == 200:
+            return response.json()
+        else:
+            log("Failed to inspect token. Status code: {}, Body: {}".format(response.status_code, response.text))
+            if response.status_code == 400 and "invalid_token" in response.text:
+                log("Access token is invalid. Deleting token.json and stopping the server.")
+                if delete_token_file_fn:
+                    delete_token_file_fn()
+                if stop_server_fn:
+                    stop_server_fn()
+                return None
+            return None
+    except Exception as e:
+        log("Exception during token inspection: {}".format(e))
+        return None

MediLink/gmail_oauth_utils.py

@@ -0,0 +1,98 @@
+import json
+import os
+import time
+import requests
+
+
+def get_authorization_url(credentials_path, redirect_uri, scopes, log):
+    """
+    Build the Google OAuth authorization URL using the provided credentials file, redirect URI, and scopes.
+    """
+    with open(credentials_path, 'r') as credentials_file:
+        credentials = json.load(credentials_file)
+    client_id = credentials['web']['client_id']
+    auth_url = (
+        "https://accounts.google.com/o/oauth2/v2/auth?"
+        "response_type=code&"
+        "client_id={}&"
+        "redirect_uri={}&"
+        "scope={}&"
+        "access_type=offline&"
+        "prompt=consent"
+    ).format(client_id, redirect_uri, scopes)
+    log("Generated authorization URL: {}".format(auth_url))
+    return auth_url
+
+
+def exchange_code_for_token(auth_code, credentials_path, redirect_uri, log, retries=3):
+    """
+    Exchange an authorization code for tokens using credentials; retries a few times on failure.
+    """
+    for attempt in range(retries):
+        try:
+            with open(credentials_path, 'r') as credentials_file:
+                credentials = json.load(credentials_file)
+            token_url = "https://oauth2.googleapis.com/token"
+            data = {
+                'code': auth_code,
+                'client_id': credentials['web']['client_id'],
+                'client_secret': credentials['web']['client_secret'],
+                'redirect_uri': redirect_uri,
+                'grant_type': 'authorization_code'
+            }
+            response = requests.post(token_url, data=data)
+            log("Token exchange response: Status code {}, Body: {}".format(response.status_code, response.text))
+            token_response = response.json()
+            if response.status_code == 200:
+                token_response['token_time'] = time.time()
+                return token_response
+            else:
+                log("Token exchange failed: {}".format(token_response))
+                if attempt < retries - 1:
+                    log("Retrying token exchange... (Attempt {}/{})".format(attempt + 1, retries))
+        except Exception as e:
+            log("Error during token exchange: {}".format(e))
+    return {}
+
+
+def refresh_access_token(refresh_token, credentials_path, log):
+    """
+    Refresh an access token using the stored client credentials.
+    """
+    log("Refreshing access token.")
+    with open(credentials_path, 'r') as credentials_file:
+        credentials = json.load(credentials_file)
+    token_url = "https://oauth2.googleapis.com/token"
+    data = {
+        'client_id': credentials['web']['client_id'],
+        'client_secret': credentials['web']['client_secret'],
+        'refresh_token': refresh_token,
+        'grant_type': 'refresh_token'
+    }
+    response = requests.post(token_url, data=data)
+    log("Refresh token response: Status code {}, Body:\n {}".format(response.status_code, response.text))
+    if response.status_code == 200:
+        log("Access token refreshed successfully.")
+        return response.json()
+    else:
+        log("Failed to refresh access token. Status code: {}".format(response.status_code))
+        return {}
+
+
+def is_valid_authorization_code(auth_code, log):
+    """
+    Validate auth code shape without side effects.
+    """
+    if auth_code and isinstance(auth_code, str) and len(auth_code) > 0:
+        return True
+    log("Invalid authorization code format: {}".format(auth_code))
+    return False
+
+
+def clear_token_cache(token_path, log):
+    """
+    Delete token cache file if present.
+    """
+    if os.path.exists(token_path):
+        os.remove(token_path)
+        log("Cleared token cache.")

{medicafe-0.250810.7.dist-info → medicafe-0.250811.0.dist-info}/METADATA

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

{medicafe-0.250810.7.dist-info → medicafe-0.250811.0.dist-info}/RECORD

@@ -6,7 +6,7 @@ MediBot/MediBot_Crosswalk_Utils.py,sha256=HQXZUWDZF_LvOMLsdjlsDQ79Yi_IiqNVRKX2Cd
 MediBot/MediBot_Post.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediBot/MediBot_Preprocessor.py,sha256=zAcfyuE8wl9JRzLGsUnnXiHxAr-hbCCIB2M-Jb3LUqI,16203
 MediBot/MediBot_Preprocessor_lib.py,sha256=L5VkBoSWuvvKNs0YoHz_-KQ5Z2hnqLJyM_j7yeKb9CM,72423
-MediBot/MediBot_UI.py,sha256=26Dx_KlNuVEwBLwmQ-uJ2fvOAbwiIYruX3-iXMtPKFc,13419
+MediBot/MediBot_UI.py,sha256=YgNr_E8ahf7Y-Emkq04PavJH37LShs83wVxp9i6EVgw,14191
 MediBot/MediBot_dataformat_library.py,sha256=XCkwhpkDbhiSDQ_21xPafqJzZLoq-C0dczoN2Xl5tHE,10260
 MediBot/MediBot_docx_decoder.py,sha256=gn7I7Ng5khVIzU0HTTOqi31YSSn1yW8Pyk-i_P9r1oA,32472
 MediBot/MediBot_smart_import.py,sha256=_ggP0I9djNwMGck04U6fNahrH7frVkoM8OzjtHbLUc0,6727
@@ -16,14 +16,14 @@ MediBot/__init__.py,sha256=6IdVLXaWxV5ZdpefonWrC1R8RsJn4V26K0PmUEZ_vU8,3192
 MediBot/get_medicafe_version.py,sha256=uyL_UIE42MyFuJ3SRYxJp8sZx8xjTqlYZ3FdQuxLduY,728
 MediBot/update_json.py,sha256=vvUF4mKCuaVly8MmoadDO59M231fCIInc0KI1EtDtPA,3704
 MediBot/update_medicafe.py,sha256=i2-6b2y9XXaroPG8uP_RPFwOOsQSY_dTiuhl6vG8uoo,25693
-MediCafe/MediLink_ConfigLoader.py,sha256=_tB8FlJSNsRDHKL2X7XMmtLcxhCeXtiaddV-jOQWHi4,7723
+MediCafe/MediLink_ConfigLoader.py,sha256=Ia79dZQBvgbc6CtOaNZVlFHaN-fvUmJRpmmVHz_MFv8,8205
 MediCafe/__init__.py,sha256=DF0XUu3G43AejXvEmd5aCyy0GDQahQD0pMwexmxem-E,5477
 MediCafe/__main__.py,sha256=mRNyk3D9Ilnu2XhgVI_rut7r5Ro7UIKtwV871giAHI8,12992
 MediCafe/api_core.py,sha256=AwnB2BMiBOMS_LKJlkHgd_lQPpE57WEYMfS-O-DeOzo,63851
 MediCafe/api_core_backup.py,sha256=Oy_Fqt0SEvGkQN1Oqw5iUPVFxPEokyju5CuPEb9k0OY,18686
 MediCafe/api_factory.py,sha256=I5AeJoyu6m7oCrjc2OvVvO_4KSBRutTsR1riiWhTZV0,12086
 MediCafe/api_utils.py,sha256=KWQB0q1k5E6frOFFlKWcFpHNcqfrS7KJ_82672wbupw,14041
-MediCafe/core_utils.py,sha256=IS6hhmMR02vmjdOLFak99mK0bA3w6qBEtm66CDLTz-Q,20686
+MediCafe/core_utils.py,sha256=yftnn2pMhfUMEHfGl9ocvLoI8kQvsDjqrRZAR3uHdWo,26317
 MediCafe/graphql_utils.py,sha256=5i_pNCNRUXox2v5zraPzUw4n7rUt9ZEAkLqVa59LWAc,45713
 MediCafe/logging_config.py,sha256=auT65LN5oDEXVhkMeLke63kJHTWxYf2o8YihAfQFgzU,5493
 MediCafe/logging_demo.py,sha256=TwUhzafna5pMdN3zSKGrpUWRqX96F1JGGsSUtr3dygs,1975
@@ -49,7 +49,7 @@ MediLink/MediLink_Deductible_Validator.py,sha256=2g-lZd-Y5fJ1mfP87vM6oABg0t5Om-7
 MediLink/MediLink_Display_Utils.py,sha256=Bl15Ofqh09KIYsNXzM6WIE97Gp_4RVUw43J0NUzIERY,3121
 MediLink/MediLink_Down.py,sha256=vZEFNWa6drpXK8DCzt3DAlHdPGdhv3HoLnQh9cppT8o,11793
 MediLink/MediLink_ERA_decoder.py,sha256=MiOtDcXnmevPfHAahIlTLlUc14VcQWAor9Xa7clA2Ts,8710
-MediLink/MediLink_Gmail.py,sha256=SCaauKBSsBXBljfwqSxIfXEXd74nYTEBo20I9ZNJksI,36926
+MediLink/MediLink_Gmail.py,sha256=C6tjw4Pd1wVHbCs97cvn4GCWIvwLT2Epc5ls0OoJ3Tg,23890
 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
@@ -66,6 +66,8 @@ MediLink/MediLink_main.py,sha256=rvKHuZUus8RvMC5-flws2q-EvXETXiJmgU2USjzMu3g,134
 MediLink/MediLink_smart_import.py,sha256=B5SfBn_4bYEWJJDolXbjnwKx_-MaqGZ76LyXQwWDV80,9838
 MediLink/Soumit_api.py,sha256=5JfOecK98ZC6NpZklZW2AkOzkjvrbYxpJpZNH3rFxDw,497
 MediLink/__init__.py,sha256=Z4Uxt4XZk4n-GwAkUoEeFiL-D7xHbttYiiWGjgKT_ng,3391
+MediLink/gmail_http_utils.py,sha256=gtqCCrzJC7e8JFQzMNrf7EbK8na2h4sfTu-NMaZ_UHc,4006
+MediLink/gmail_oauth_utils.py,sha256=MLuzO6awBanV7Ee2gOUrkWrxz8-Htwz2BEIFjLw9Izs,3734
 MediLink/insurance_type_integration_test.py,sha256=pz2OCXitAznqDciYn6OL9M326m9CYU7YiK-ynssdQ5g,15172
 MediLink/openssl.cnf,sha256=76VdcGCykf0Typyiv8Wd1mMVKixrQ5RraG6HnfKFqTo,887
 MediLink/test.py,sha256=DM_E8gEbhbVfTAm3wTMiNnK2GCD1e5eH6gwTk89QIc4,3116
@@ -73,9 +75,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.250810.7.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
-medicafe-0.250810.7.dist-info/METADATA,sha256=5UlQ0WF3yu07a8mS6d-MZI_uCayxQ2-O43P6vii4Cjw,5501
-medicafe-0.250810.7.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-medicafe-0.250810.7.dist-info/entry_points.txt,sha256=m3RBUBjr-xRwEkKJ5W4a7NlqHZP_1rllGtjZnrRqKe8,52
-medicafe-0.250810.7.dist-info/top_level.txt,sha256=U6-WBJ9RCEjyIs0BlzbQq_PwedCp_IV9n1616NNV5zA,26
-medicafe-0.250810.7.dist-info/RECORD,,
+medicafe-0.250811.0.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
+medicafe-0.250811.0.dist-info/METADATA,sha256=tnhM2Rn4jbS9mJ7VGw4ncPYfdb-Do_izp0kzOImKs0c,5501
+medicafe-0.250811.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+medicafe-0.250811.0.dist-info/entry_points.txt,sha256=m3RBUBjr-xRwEkKJ5W4a7NlqHZP_1rllGtjZnrRqKe8,52
+medicafe-0.250811.0.dist-info/top_level.txt,sha256=U6-WBJ9RCEjyIs0BlzbQq_PwedCp_IV9n1616NNV5zA,26
+medicafe-0.250811.0.dist-info/RECORD,,