medicafe 0.250805.0__tar.gz → 0.250806.0__tar.gz

{medicafe-0.250805.0 → medicafe-0.250806.0}/MediBot/update_medicafe.py

@@ -15,6 +15,40 @@ except ImportError:
     requests = None
     print("Warning: requests module not available. Some functionality may be limited.")
 
+def print_status(message, status_type="INFO"):
+    """Print formatted status messages with ASCII-only visual indicators."""
+    if status_type == "SUCCESS":
+        print("\n" + "="*60)
+        print("[SUCCESS] {}".format(message))
+        print("="*60)
+    elif status_type == "ERROR":
+        print("\n" + "="*60)
+        print("[ERROR] {}".format(message))
+        print("="*60)
+    elif status_type == "WARNING":
+        print("\n" + "-"*60)
+        print("[WARNING] {}".format(message))
+        print("-"*60)
+    elif status_type == "INFO":
+        print("\n" + "-"*60)
+        print("[INFO] {}".format(message))
+        print("-"*60)
+    else:
+        print(message)
+
+def print_final_result(success, message):
+    """Print final result with clear visual indication."""
+    if success:
+        print_status("UPDATE COMPLETED SUCCESSFULLY", "SUCCESS")
+        print("Final Status: {}".format(message))
+    else:
+        print_status("UPDATE FAILED", "ERROR")
+        print("Final Status: {}".format(message))
+    
+    print("\nExiting in 5 seconds...")
+    time.sleep(5)
+    sys.exit(0 if success else 1)
+
 def get_installed_version(package):
     try:
         process = subprocess.Popen(
@@ -88,9 +122,8 @@ def upgrade_package(package, retries=3, delay=2):  # Updated retries to 3
     Attempts to upgrade the package multiple times with delays in between.
     """
     if not check_internet_connection():
-        print("Error: No internet connection detected. Please check your internet connection and try again.")
-        time.sleep(3)  # Pause for 3 seconds before exiting
-        sys.exit(1)
+        print_status("No internet connection detected. Please check your internet connection and try again.", "ERROR")
+        print_final_result(False, "No internet connection available")
     
     for attempt in range(1, retries + 1):
         print("Attempt {} to upgrade {}...".format(attempt, package))
@@ -110,24 +143,24 @@ def upgrade_package(package, retries=3, delay=2):  # Updated retries to 3
             new_version = get_installed_version(package)  # Get new version after upgrade
             if compare_versions(new_version, get_latest_version(package)) >= 0:  # Compare versions
                 if attempt == 1:
-                    print("Upgrade succeeded!")
+                    print_status("Upgrade succeeded!", "SUCCESS")
                 else:
-                    print("Attempt {}: Upgrade succeeded!".format(attempt))
+                    print_status("Attempt {}: Upgrade succeeded!".format(attempt), "SUCCESS")
                 time.sleep(delay)
                 return True
             else:
-                print("Upgrade failed. Current version remains: {}".format(new_version))
+                print_status("Upgrade failed. Current version remains: {}".format(new_version), "WARNING")
                 if attempt < retries:
                     print("Retrying in {} seconds...".format(delay))
                     time.sleep(delay)
         else:
             print(stderr.decode().strip())
-            print("Attempt {}: Upgrade failed.".format(attempt))
+            print_status("Attempt {}: Upgrade failed.".format(attempt), "WARNING")
             if attempt < retries:
                 print("Retrying in {} seconds...".format(delay))
                 time.sleep(delay)
     
-    print("Error: All upgrade attempts failed.")
+    print_status("All upgrade attempts failed.", "ERROR")
     return False
 
 def ensure_dependencies():
@@ -149,7 +182,7 @@ def ensure_dependencies():
     is_windows_py34 = sys.version_info[:2] == (3, 4) and platform.system() == 'Windows'
 
     if is_windows_py34:
-        print("Detected Windows with Python 3.4")
+        print_status("Detected Windows with Python 3.4", "INFO")
         print("Please ensure the following packages are installed manually:")
         for pkg in problematic_packages:
             package_name, version = pkg.split('==')
@@ -187,7 +220,7 @@ def ensure_dependencies():
                 print("Required version of {}: {}".format(package_name, version))
                 time.sleep(2)  # Pause for 2 seconds to allow user to read the output
                 if not upgrade_package(package_name):  # Attempt to upgrade/downgrade to the required version
-                    print("Warning: Failed to upgrade/downgrade {} to version {}.".format(package_name, version))
+                    print_status("Failed to upgrade/downgrade {} to version {}.".format(package_name, version), "WARNING")
                     time.sleep(2)  # Pause for 2 seconds after failure message
             elif version and installed_version == version:  # Check if installed version matches required version
                 print("All versions match for {}. No changes needed.".format(package_name))
@@ -199,13 +232,13 @@ def ensure_dependencies():
                     print("Latest version of {}: {}".format(package_name, latest_version))
                     time.sleep(2)  # Pause for 2 seconds to allow user to read the output
                     if not upgrade_package(package_name):
-                        print("Warning: Failed to upgrade {}.".format(package_name))
+                        print_status("Failed to upgrade {}.".format(package_name), "WARNING")
                         time.sleep(2)  # Pause for 2 seconds after failure message
         except pkg_resources.DistributionNotFound:
             print("Package {} is not installed. Attempting to install...".format(package_name))
             time.sleep(2)  # Pause for 2 seconds before attempting installation
             if not upgrade_package(package_name):
-                print("Warning: Failed to install {}.".format(package_name))
+                print_status("Failed to install {}.".format(package_name), "WARNING")
                 time.sleep(2)  # Pause for 2 seconds after failure message
 
 def check_for_updates_only():
@@ -234,56 +267,54 @@ def check_for_updates_only():
         print("UP_TO_DATE")
 
 def main():
+    print_status("MediCafe Update Utility", "INFO")
+    print("Starting update process...")
+    
     # Ensure internet connection before proceeding
     if not check_internet_connection():
-        print("Error: No internet connection. Please check your connection and try again.")
-        time.sleep(3)  # Pause for 3 seconds before exiting
-        sys.exit(1)
+        print_status("No internet connection. Please check your connection and try again.", "ERROR")
+        print_final_result(False, "No internet connection available")
 
     # Ensure all dependencies are met before proceeding
     response = input("Do you want to check dependencies? (yes/no, default/enter is no): ").strip().lower()
     if response in ['yes', 'y']:
         ensure_dependencies()
     else:
-        print("Skipping dependency check.")
+        print_status("Skipping dependency check.", "INFO")
         time.sleep(3)  # Pause for 3 seconds before proceeding
 
     package = "medicafe"
     
     current_version = get_installed_version(package)
     if not current_version:
-        print("{} is not installed.".format(package))
-        time.sleep(3)  # Pause for 3 seconds before exiting
-        sys.exit(1)
+        print_status("{} is not installed.".format(package), "ERROR")
+        print_final_result(False, "Package not installed")
     
     latest_version = get_latest_version(package)
     if not latest_version:
-        print("Could not retrieve the latest version information.")
-        time.sleep(3)  # Pause for 3 seconds before exiting
-        sys.exit(1)
+        print_status("Could not retrieve the latest version information.", "ERROR")
+        print_final_result(False, "Unable to fetch latest version")
     
     print("Current version of {}: {}".format(package, current_version))
     print("Latest version of {}: {}".format(package, latest_version))
     
     if compare_versions(latest_version, current_version) > 0:
-        print("A newer version is available. Proceeding with upgrade.")
+        print_status("A newer version is available. Proceeding with upgrade.", "INFO")
         if upgrade_package(package):
             # Verify upgrade
             time.sleep(3)
             new_version = get_installed_version(package)
             if compare_versions(new_version, latest_version) >= 0:
-                print("Upgrade successful. New version: {}".format(new_version))
+                print_status("Upgrade successful. New version: {}".format(new_version), "SUCCESS")
+                print_final_result(True, "Successfully upgraded to version {}".format(new_version))
             else:
-                print("Upgrade failed. Current version remains: {}".format(new_version))
-                time.sleep(3)  # Pause for 3 seconds before exiting
-                sys.exit(1)
+                print_status("Upgrade failed. Current version remains: {}".format(new_version), "ERROR")
+                print_final_result(False, "Upgrade verification failed")
         else:
-            time.sleep(3)  # Pause for 3 seconds before exiting
-            sys.exit(1)
+            print_final_result(False, "Upgrade process failed")
     else:
-        print("You already have the latest version installed.")
-        time.sleep(3)  # Pause for 3 seconds before exiting
-        sys.exit(1)
+        print_status("You already have the latest version installed.", "SUCCESS")
+        print_final_result(True, "Already running latest version")
 
 if __name__ == "__main__":
     if len(sys.argv) > 1 and sys.argv[1] == "--check-only":

{medicafe-0.250805.0 → medicafe-0.250806.0}/MediCafe/__main__.py

@@ -24,7 +24,7 @@ batch script without adding unnecessary interface layers.
 import sys
 import os
 import argparse
-import os
+import subprocess
 
 # Set up module paths for proper imports
 def setup_entry_point_paths():
@@ -90,10 +90,33 @@ def run_medilink():
     """Run MediLink application"""
     try:
         print("Starting MediLink...")
-        # Import and execute MediLink
-        import runpy
-        exit_code = runpy.run_module('MediLink.MediLink_main', run_name='__main__')
-        return 0
+        # Use subprocess.call for Python 3.4.4 compatibility
+        
+        # Get the path to MediLink_main.py
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        workspace_root = os.path.dirname(current_dir)
+        medilink_main_path = os.path.join(workspace_root, 'MediLink', 'MediLink_main.py')
+        
+        if os.path.exists(medilink_main_path):
+            # Set up environment for subprocess to find MediCafe
+            env = os.environ.copy()
+            python_path = workspace_root
+            if 'PYTHONPATH' in env:
+                env['PYTHONPATH'] = python_path + os.pathsep + env['PYTHONPATH']
+            else:
+                env['PYTHONPATH'] = python_path
+            
+            # Set working directory to MediLink directory for proper file paths
+            medilink_dir = os.path.dirname(medilink_main_path)
+            
+            # Use subprocess.call for Python 3.4.4 compatibility
+            result = subprocess.call([sys.executable, medilink_main_path], 
+                                   cwd=medilink_dir,
+                                   env=env)
+            return result
+        else:
+            print("Error: MediLink_main.py not found at {}".format(medilink_main_path))
+            return 1
         
     except ImportError as e:
         print("Error: Unable to import MediLink: {}".format(e))
@@ -106,10 +129,33 @@ def run_claims_status():
     """Run United Claims Status checker"""
     try:
         print("Starting United Claims Status...")
-        # Import and execute Claims Status
-        import runpy
-        exit_code = runpy.run_module('MediLink.MediLink_ClaimStatus', run_name='__main__')
-        return 0
+        # Use subprocess.call for Python 3.4.4 compatibility
+        
+        # Get the path to MediLink_ClaimStatus.py
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        workspace_root = os.path.dirname(current_dir)
+        claims_status_path = os.path.join(workspace_root, 'MediLink', 'MediLink_ClaimStatus.py')
+        
+        if os.path.exists(claims_status_path):
+            # Set up environment for subprocess to find MediCafe
+            env = os.environ.copy()
+            python_path = workspace_root
+            if 'PYTHONPATH' in env:
+                env['PYTHONPATH'] = python_path + os.pathsep + env['PYTHONPATH']
+            else:
+                env['PYTHONPATH'] = python_path
+            
+            # Set working directory to MediLink directory for proper file paths
+            medilink_dir = os.path.dirname(claims_status_path)
+            
+            # Use subprocess.call for Python 3.4.4 compatibility
+            result = subprocess.call([sys.executable, claims_status_path], 
+                                   cwd=medilink_dir,
+                                   env=env)
+            return result
+        else:
+            print("Error: MediLink_ClaimStatus.py not found at {}".format(claims_status_path))
+            return 1
         
     except ImportError as e:
         print("Error: Unable to import MediLink_ClaimStatus: {}".format(e))
@@ -122,10 +168,33 @@ def run_deductible():
     """Run United Deductible checker"""
     try:
         print("Starting United Deductible...")
-        # Import and execute Deductible checker
-        import runpy
-        exit_code = runpy.run_module('MediLink.MediLink_Deductible', run_name='__main__')
-        return 0
+        # Use subprocess.call for Python 3.4.4 compatibility
+        
+        # Get the path to MediLink_Deductible.py
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        workspace_root = os.path.dirname(current_dir)
+        deductible_path = os.path.join(workspace_root, 'MediLink', 'MediLink_Deductible.py')
+        
+        if os.path.exists(deductible_path):
+            # Set up environment for subprocess to find MediCafe
+            env = os.environ.copy()
+            python_path = workspace_root
+            if 'PYTHONPATH' in env:
+                env['PYTHONPATH'] = python_path + os.pathsep + env['PYTHONPATH']
+            else:
+                env['PYTHONPATH'] = python_path
+            
+            # Set working directory to MediLink directory for proper file paths
+            medilink_dir = os.path.dirname(deductible_path)
+            
+            # Use subprocess.call for Python 3.4.4 compatibility
+            result = subprocess.call([sys.executable, deductible_path], 
+                                   cwd=medilink_dir,
+                                   env=env)
+            return result
+        else:
+            print("Error: MediLink_Deductible.py not found at {}".format(deductible_path))
+            return 1
         
     except ImportError as e:
         print("Error: Unable to import MediLink_Deductible: {}".format(e))
@@ -138,10 +207,33 @@ def run_download_emails():
     """Run email download functionality"""
     try:
         print("Starting email download...")
-        # Import and execute Gmail downloader
-        import runpy
-        exit_code = runpy.run_module('MediLink.MediLink_Gmail', run_name='__main__')
-        return 0
+        # Use subprocess.call for Python 3.4.4 compatibility
+        
+        # Get the path to MediLink_Gmail.py
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        workspace_root = os.path.dirname(current_dir)
+        medilink_gmail_path = os.path.join(workspace_root, 'MediLink', 'MediLink_Gmail.py')
+        
+        if os.path.exists(medilink_gmail_path):
+            # Set up environment for subprocess to find MediCafe
+            env = os.environ.copy()
+            python_path = workspace_root
+            if 'PYTHONPATH' in env:
+                env['PYTHONPATH'] = python_path + os.pathsep + env['PYTHONPATH']
+            else:
+                env['PYTHONPATH'] = python_path
+            
+            # Set working directory to MediLink directory for proper file paths
+            medilink_dir = os.path.dirname(medilink_gmail_path)
+            
+            # Use subprocess.call for Python 3.4.4 compatibility
+            result = subprocess.call([sys.executable, medilink_gmail_path], 
+                                   cwd=medilink_dir,
+                                   env=env)
+            return result
+        else:
+            print("Error: MediLink_Gmail.py not found at {}".format(medilink_gmail_path))
+            return 1
         
     except ImportError as e:
         print("Error: Unable to import MediLink_Gmail: {}".format(e))

{medicafe-0.250805.0 → medicafe-0.250806.0}/MediLink/MediLink_Gmail.py

@@ -1,5 +1,19 @@
 # MediLink_Gmail.py
 import sys, os, subprocess, time, webbrowser, requests, json, ssl, signal
+
+# Set up Python path to find MediCafe when running directly
+def setup_python_path():
+    """Set up Python path to find MediCafe package"""
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    workspace_root = os.path.dirname(current_dir)
+    
+    # Add workspace root to Python path if not already present
+    if workspace_root not in sys.path:
+        sys.path.insert(0, workspace_root)
+
+# Set up paths before importing MediCafe
+setup_python_path()
+
 from MediCafe.core_utils import get_shared_config_loader
 
 # Get shared config loader
@@ -26,18 +40,26 @@ server_port = 8000
 cert_file = 'server.cert'
 key_file = 'server.key'
 # Try to find openssl.cnf in various locations
-openssl_cnf = 'MediLink\\openssl.cnf'
+openssl_cnf = 'openssl.cnf'  # Use relative path since we're running from MediLink directory
 if not os.path.exists(openssl_cnf):
     log("Could not find openssl.cnf at: " + os.path.abspath(openssl_cnf))
-    # Try one directory up
-    parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    alternative_path = os.path.join(parent_dir, 'MediBot', 'openssl.cnf')
-    log("Trying alternative path: " + alternative_path)
-    if os.path.exists(alternative_path):
-        openssl_cnf = alternative_path
+    # Try MediLink directory
+    medilink_dir = os.path.dirname(os.path.abspath(__file__))
+    medilink_openssl = os.path.join(medilink_dir, 'openssl.cnf')
+    log("Trying MediLink directory: " + medilink_openssl)
+    if os.path.exists(medilink_openssl):
+        openssl_cnf = medilink_openssl
         log("Found openssl.cnf at: " + openssl_cnf)
     else:
-        log("Could not find openssl.cnf at alternative path either")
+        # Try one directory up
+        parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        alternative_path = os.path.join(parent_dir, 'MediBot', 'openssl.cnf')
+        log("Trying alternative path: " + alternative_path)
+        if os.path.exists(alternative_path):
+            openssl_cnf = alternative_path
+            log("Found openssl.cnf at: " + openssl_cnf)
+        else:
+            log("Could not find openssl.cnf at alternative path either")
 
 httpd = None  # Global variable for the HTTP server
 shutdown_event = Event()  # Event to signal shutdown

{medicafe-0.250805.0 → medicafe-0.250806.0}/PKG-INFO

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

{medicafe-0.250805.0 → medicafe-0.250806.0}/medicafe.egg-info/PKG-INFO

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

{medicafe-0.250805.0 → medicafe-0.250806.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='medicafe',
-    version="0.250805.0",
+    version="0.250806.0",
     description='MediCafe',
     long_description="""
     # Project Overview: MediCafe