medicafe 0.250810.3__tar.gz → 0.250810.5__tar.gz

{medicafe-0.250810.3 → medicafe-0.250810.5}/MediBot/MediBot.bat

@@ -557,7 +557,6 @@ if errorlevel 1 (
     pause
 )
 
-pause
 goto main_menu
 
 :: MediLink Flow
@@ -571,7 +570,6 @@ if errorlevel 1 (
     pause
 )
 
-pause
 goto main_menu
 
 :toggle_perf_logging

{medicafe-0.250810.3 → medicafe-0.250810.5}/MediBot/update_medicafe.py

@@ -84,6 +84,18 @@ def print_final_result(success, message):
 
 def get_installed_version(package):
     try:
+        # First try using pkg_resources directly (more reliable for Python 3.4)
+        if pkg_resources:
+            try:
+                version = pkg_resources.get_distribution(package).version
+                return version
+            except pkg_resources.DistributionNotFound:
+                return None
+            except Exception as e:
+                print("Warning: pkg_resources failed: {}".format(e))
+                # Fall through to pip method
+        
+        # Fallback to pip show (may fail on Python 3.4 due to packaging issues)
         process = subprocess.Popen(
             [sys.executable, '-m', 'pip', 'show', package],
             stdout=subprocess.PIPE,
@@ -114,30 +126,29 @@ def get_latest_version(package, retries=3, delay=1):
             data = response.json()
             latest_version = data['info']['version']
             
-            # Print the version with attempt information (only in debug mode)
-            if DEBUG_MODE:
-                if attempt == 1:
-                    print("Latest available version: {}".format(latest_version))
-                else:
-                    print("Latest available version: {} ({} attempt)".format(latest_version, attempt))
+            # Print the version with attempt information
+            if attempt == 1:
+                print("Latest available version: {}".format(latest_version))
+            else:
+                print("Latest available version: {} ({} attempt)".format(latest_version, attempt))
             
             # Check if the latest version is different from the current version
             current_version = get_installed_version(package)
             if current_version and compare_versions(latest_version, current_version) == 0:
-                # If the versions are the same, perform a second request
+                # If the versions are the same, perform a second request to ensure we have the latest
                 time.sleep(delay)
                 response = requests.get("https://pypi.org/pypi/{}/json".format(package), timeout=10)
                 response.raise_for_status()
                 data = response.json()
                 latest_version = data['info']['version']
+                print("Double-checked latest version: {}".format(latest_version))
             
             return latest_version  # Return the version after the check
         except requests.RequestException as e:
-            if DEBUG_MODE:
-                print("Attempt {}: Error fetching latest version: {}".format(attempt, e))
-                if attempt < retries:
-                    print("Retrying in {} seconds...".format(delay))
-            time.sleep(delay)
+            print("Attempt {}: Error fetching latest version: {}".format(attempt, e))
+            if attempt < retries:
+                print("Retrying in {} seconds...".format(delay))
+                time.sleep(delay)
     return None
 
 def check_internet_connection():
@@ -159,8 +170,7 @@ def clear_python_cache(workspace_path=None):
         bool: True if cache was cleared successfully, False otherwise
     """
     try:
-        if DEBUG_MODE:
-            print_status("Clearing Python bytecode cache...", "INFO")
+        print_status("Clearing Python bytecode cache...", "INFO")
         
         # If no workspace path provided, try to detect it
         if not workspace_path:
@@ -181,12 +191,10 @@ def clear_python_cache(workspace_path=None):
                     break
         
         if not workspace_path:
-            if DEBUG_MODE:
-                print_status("Could not detect workspace path. Cache clearing skipped.", "WARNING")
+            print_status("Could not detect workspace path. Cache clearing skipped.", "WARNING")
             return False
         
-        if DEBUG_MODE:
-            print("Workspace path: {}".format(workspace_path))
+        print("Workspace path: {}".format(workspace_path))
         
         # Directories to clear cache from
         cache_dirs = [
@@ -204,12 +212,10 @@ def clear_python_cache(workspace_path=None):
                 if os.path.exists(pycache_path):
                     try:
                         shutil.rmtree(pycache_path)
-                        if DEBUG_MODE:
-                            print("Cleared cache: {}".format(pycache_path))
+                        print("Cleared cache: {}".format(pycache_path))
                         cleared_count += 1
                     except Exception as e:
-                        if DEBUG_MODE:
-                            print("Warning: Could not clear cache at {}: {}".format(pycache_path, e))
+                        print("Warning: Could not clear cache at {}: {}".format(pycache_path, e))
                 
                 # Remove .pyc files
                 for root, dirs, files in os.walk(cache_dir):
@@ -217,25 +223,20 @@ def clear_python_cache(workspace_path=None):
                         if file.endswith('.pyc'):
                             try:
                                 os.remove(os.path.join(root, file))
-                                if DEBUG_MODE:
-                                    print("Removed .pyc file: {}".format(os.path.join(root, file)))
+                                print("Removed .pyc file: {}".format(os.path.join(root, file)))
                                 cleared_count += 1
                             except Exception as e:
-                                if DEBUG_MODE:
-                                    print("Warning: Could not remove .pyc file {}: {}".format(file, e))
+                                print("Warning: Could not remove .pyc file {}: {}".format(file, e))
         
         if cleared_count > 0:
-            if DEBUG_MODE:
-                print_status("Successfully cleared {} cache items".format(cleared_count), "SUCCESS")
+            print_status("Successfully cleared {} cache items".format(cleared_count), "SUCCESS")
             return True
         else:
-            if DEBUG_MODE:
-                print_status("No cache files found to clear", "INFO")
+            print_status("No cache files found to clear", "INFO")
             return True
             
     except Exception as e:
-        if DEBUG_MODE:
-            print_status("Error clearing cache: {}".format(e), "ERROR")
+        print_status("Error clearing cache: {}".format(e), "ERROR")
         return False
 
 def compare_versions(version1, version2):
@@ -252,22 +253,20 @@ def upgrade_package(package, retries=3, delay=2):  # Updated retries to 3
         print_final_result(False, "No internet connection available")
     
     for attempt in range(1, retries + 1):
-        if DEBUG_MODE:
-            print("Attempt {} to upgrade {}...".format(attempt, package))
-        process = subprocess.Popen(
-            [
-                sys.executable, '-m', 'pip', 'install', '--upgrade',
-                package, '--no-cache-dir', '--disable-pip-version-check', '-q'
-            ],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
-        )
+        print("Attempt {} to upgrade {}...".format(attempt, package))
         
+        # Use a more compatible approach for Python 3.4
+        # Try with --no-deps first to avoid dependency resolution issues
+        cmd = [
+            sys.executable, '-m', 'pip', 'install', '--upgrade',
+            '--no-deps', '--no-cache-dir', '--disable-pip-version-check', '-q', package
+        ]
+        
+        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         stdout, stderr = process.communicate()
         
         if process.returncode == 0:
-            if DEBUG_MODE:
-                print(stdout.decode().strip())
+            print(stdout.decode().strip())
             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:
@@ -279,17 +278,39 @@ def upgrade_package(package, retries=3, delay=2):  # Updated retries to 3
             else:
                 print_status("Upgrade failed. Current version remains: {}".format(new_version), "WARNING")
                 if attempt < retries:
-                    if DEBUG_MODE:
-                        print("Retrying in {} seconds...".format(delay))
+                    print("Retrying in {} seconds...".format(delay))
                     time.sleep(delay)
         else:
-            if DEBUG_MODE:
-                print(stderr.decode().strip())
-            print_status("Attempt {}: Upgrade failed.".format(attempt), "WARNING")
+            print(stderr.decode().strip())
+            print_status("Attempt {}: Upgrade failed with --no-deps.".format(attempt), "WARNING")
+            
+            # If --no-deps failed, try with --force-reinstall to bypass dependency issues
             if attempt < retries:
-                if DEBUG_MODE:
+                print("Retrying with --force-reinstall...")
+                cmd = [
+                    sys.executable, '-m', 'pip', 'install', '--upgrade',
+                    '--force-reinstall', '--no-cache-dir', '--disable-pip-version-check', '-q', package
+                ]
+                
+                process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                stdout, stderr = process.communicate()
+                
+                if process.returncode == 0:
+                    print(stdout.decode().strip())
+                    new_version = get_installed_version(package)
+                    if compare_versions(new_version, get_latest_version(package)) >= 0:
+                        print_status("Attempt {}: Upgrade succeeded with --force-reinstall!".format(attempt), "SUCCESS")
+                        time.sleep(delay)
+                        return True
+                    else:
+                        print_status("Upgrade failed. Current version remains: {}".format(new_version), "WARNING")
+                else:
+                    print(stderr.decode().strip())
+                    print_status("Attempt {}: Upgrade failed with --force-reinstall.".format(attempt), "WARNING")
+                
+                if attempt < retries:
                     print("Retrying in {} seconds...".format(delay))
-                time.sleep(delay)
+                    time.sleep(delay)
     
     print_status("All upgrade attempts failed.", "ERROR")
     return False
@@ -402,170 +423,130 @@ def main():
     # Enable debug mode if requested via CLI or environment
     DEBUG_MODE = ('--debug' in sys.argv) or (os.environ.get('MEDICAFE_DEBUG', '0') in ['1', 'true', 'TRUE'])
 
-    # Always show the header for user feedback
-    print("="*60)
-    print("MediCafe Update Utility")
-    print("="*60)
-    print("Timestamp: {}".format(time.strftime("%Y-%m-%d %H:%M:%S")))
-    print("Python Version: {}".format(sys.version.split()[0]))
-    print("Platform: {}".format(platform.system()))
-    print("="*60)
-    print()
-    
-    # STEP 1: Environment Information (always show basic info)
-    print("STEP 1: Environment Check")
-    print("-" * 40)
-    print("Working Directory: {}".format(os.getcwd()))
-    print("Script Location: {}".format(os.path.basename(__file__)))
-    print("Python Executable: {}".format(sys.executable))
-    print()
-    
-    # STEP 2: Check Python and pip (always verify)
-    print("STEP 2: Python Environment")
-    print("-" * 40)
+    print_status("MediCafe Update Utility", "INFO")
+    print("Starting update process...")
+
+    # STEP 1: Environment Information
+    debug_step(1, "Environment Information",
+              "Python version: {}\n"
+              "Platform: {}\n"
+              "Current working directory: {}\n"
+              "Script location: {}\n"
+              "sys.executable: {}".format(
+                  sys.version, platform.platform(), os.getcwd(),
+                  __file__, sys.executable))
+
+    # STEP 2: Check Python and pip
+    debug_step(2, "Python and pip Verification")
     print("Checking Python installation...")
     try:
-        process = subprocess.Popen([sys.executable, '--version'], 
+        process = subprocess.Popen([sys.executable, '--version'],
                                  stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         stdout, stderr = process.communicate()
         if process.returncode == 0:
-            print("Python: {}".format(stdout.decode().strip()))
+            print("Python version: {}".format(stdout.decode().strip()))
         else:
-            print("Python: ERROR - {}".format(stderr.decode().strip()))
-            print_final_result(False, "Python installation check failed")
+            print("Error checking Python: {}".format(stderr.decode().strip()))
     except Exception as e:
-        print("Python: ERROR - {}".format(e))
-        print_final_result(False, "Python installation check failed")
-    
-    print("Checking pip installation...")
+        print("Error checking Python: {}".format(e))
+
+    print("\nChecking pip installation...")
     try:
-        process = subprocess.Popen([sys.executable, '-m', 'pip', '--version'], 
+        process = subprocess.Popen([sys.executable, '-m', 'pip', '--version'],
                                  stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         stdout, stderr = process.communicate()
         if process.returncode == 0:
-            print("pip: {}".format(stdout.decode().strip()))
+            print("pip version: {}".format(stdout.decode().strip()))
         else:
-            print("pip: ERROR - {}".format(stderr.decode().strip()))
-            print_final_result(False, "pip installation check failed")
+            print("Error checking pip: {}".format(stderr.decode().strip()))
     except Exception as e:
-        print("pip: ERROR - {}".format(e))
-        print_final_result(False, "pip installation check failed")
-    print()
-    
-    # STEP 3: Check MediCafe package (always check)
-    print("STEP 3: MediCafe Package")
-    print("-" * 40)
+        print("Error checking pip: {}".format(e))
+
+    # STEP 3: Check MediCafe package
+    debug_step(3, "MediCafe Package Check")
     package = "medicafe"
     current_version = get_installed_version(package)
     if current_version:
-        print("Current Version: {}".format(current_version))
+        print("Current MediCafe version: {}".format(current_version))
     else:
-        print("MediCafe: NOT INSTALLED")
-        print("Attempting to install MediCafe...")
-        if upgrade_package(package):
-            current_version = get_installed_version(package)
-            if current_version:
-                print("MediCafe installed successfully: {}".format(current_version))
-            else:
-                print_final_result(False, "Failed to install MediCafe")
-        else:
-            print_final_result(False, "Failed to install MediCafe")
-    print()
-    
-    # STEP 4: Internet connectivity (always check)
-    print("STEP 4: Internet Connection")
-    print("-" * 40)
-    print("Testing internet connectivity...")
+        print("MediCafe package not found or not accessible")
+
+    # STEP 4: Internet connectivity
+    debug_step(4, "Internet Connectivity Test")
     if check_internet_connection():
-        print("Internet: CONNECTED")
-        if DEBUG_MODE:
-            print("Testing PyPI connectivity...")
-            try:
-                response = requests.get("https://pypi.org/pypi/medicafe/json", timeout=10)
-                print("PyPI: CONNECTED (Status: {})".format(response.status_code))
-            except Exception as e:
-                print("PyPI: ERROR - {}".format(e))
+        print("Internet connection: OK")
+        print("Testing PyPI connectivity...")
+        try:
+            response = requests.get("https://pypi.org/pypi/medicafe/json", timeout=10)
+            print("PyPI connectivity: OK (Status: {})".format(response.status_code))
+        except Exception as e:
+            print("PyPI connectivity: FAILED - {}".format(e))
     else:
-        print("Internet: NOT CONNECTED")
+        print("Internet connection: FAILED")
         print_final_result(False, "No internet connection available")
-    print()
-    
-    # STEP 5: Check for updates (always check)
-    print("STEP 5: Version Check")
-    print("-" * 40)
+
+    # STEP 5: Check for updates
+    debug_step(5, "Version Comparison")
     latest_version = get_latest_version(package)
     if latest_version:
-        print("Latest Available: {}".format(latest_version))
+        print("Latest available version: {}".format(latest_version))
         if current_version:
             comparison = compare_versions(latest_version, current_version)
             if comparison > 0:
-                print("Status: UPDATE NEEDED")
-                print("Current: {} -> Latest: {}".format(current_version, latest_version))
+                print("Update needed: Current ({}) < Latest ({})".format(current_version, latest_version))
             elif comparison == 0:
-                print("Status: UP TO DATE")
-                print("Current: {} = Latest: {}".format(current_version, latest_version))
+                print("Already up to date: Current ({}) = Latest ({})".format(current_version, latest_version))
             else:
-                print("Status: VERSION MISMATCH")
-                print("Current: {} > Latest: {}".format(current_version, latest_version))
+                print("Version mismatch: Current ({}) > Latest ({})".format(current_version, latest_version))
         else:
-            print("Status: CANNOT COMPARE")
-            print("Current version not available")
+            print("Cannot compare versions - current version not available")
     else:
-        print("Status: ERROR")
-        print("Could not retrieve latest version")
+        print("Could not retrieve latest version information")
         print_final_result(False, "Unable to fetch latest version")
-    print()
-    
-    # STEP 6: Dependencies check (only in debug mode)
+
+    # STEP 6: Dependencies check (skipped by default in streamlined mode)
+    debug_step(6, "Dependencies Check")
     if DEBUG_MODE:
-        print("STEP 6: Dependencies Check")
-        print("-" * 40)
-        response = input("Check dependencies? (y/n, default=n): ").strip().lower()
+        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()
-    
-    # STEP 7: Perform update (always show progress)
-    print("STEP 7: Update Process")
-    print("-" * 40)
+            print_status("Skipping dependency check.", "INFO")
+    else:
+        print_status("Skipping dependency check (streamlined mode).", "INFO")
+
+    # STEP 7: Perform update
+    debug_step(7, "Update Execution")
     if current_version and latest_version and compare_versions(latest_version, current_version) > 0:
-        print("Starting update process...")
-        print("From: {} -> To: {}".format(current_version, latest_version))
-        print()
-        
+        print_status("A newer version is available. Proceeding with upgrade.", "INFO")
+        print("Current version: {}".format(current_version))
+        print("Target version: {}".format(latest_version))
+
         if upgrade_package(package):
             # STEP 8: Verify upgrade
-            print("STEP 8: Verification")
-            print("-" * 40)
+            debug_step(8, "Upgrade Verification")
             new_version = get_installed_version(package)
-            print("New Version: {}".format(new_version))
-            
+            print("New installed version: {}".format(new_version))
+
             if compare_versions(new_version, latest_version) >= 0:
-                print("Status: SUCCESS")
-                
-                # STEP 9: Clear cache (always do, minimal output)
-                print("STEP 9: Cache Cleanup")
-                print("-" * 40)
-                print("Clearing Python cache...")
+                print_status("Upgrade successful. New version: {}".format(new_version), "SUCCESS")
+
+                # DEBUG STEP 9: Clear cache
+                debug_step(9, "Cache Clearing")
+                print_status("Clearing Python cache to prevent import issues...", "INFO")
                 if clear_python_cache():
-                    print("Cache: CLEARED")
+                    print_status("Cache cleared successfully. Update complete.", "SUCCESS")
                 else:
-                    print("Cache: WARNING - Some files could not be cleared")
-                
+                    print_status("Cache clearing failed, but update was successful.", "WARNING")
+
                 print_final_result(True, "Successfully upgraded to version {}".format(new_version))
             else:
-                print("Status: FAILED")
-                print("Version verification failed")
+                print_status("Upgrade failed. Current version remains: {}".format(new_version), "ERROR")
                 print_final_result(False, "Upgrade verification failed")
         else:
-            print("Status: FAILED")
-            print("Update process failed")
             print_final_result(False, "Upgrade process failed")
     else:
-        print("Status: NO UPDATE NEEDED")
-        print("MediCafe is already up to date.")
+        print_status("You already have the latest version installed.", "SUCCESS")
         print_final_result(True, "Already running latest version")
 
 if __name__ == "__main__":

{medicafe-0.250810.3 → medicafe-0.250810.5}/MediCafe/__main__.py

@@ -38,50 +38,43 @@ def setup_entry_point_paths():
     if workspace_str not in sys.path:
         sys.path.insert(0, workspace_str)
     
-    # Also add MediBot and MediLink directories specifically
-    medibot_dir = os.path.join(workspace_root, 'MediBot')
-    medilink_dir = os.path.join(workspace_root, 'MediLink')
-    
-    if medibot_dir not in sys.path:
-        sys.path.insert(0, medibot_dir)
-    if medilink_dir not in sys.path:
-        sys.path.insert(0, medilink_dir)
+    # Ensure we do NOT add package directories directly; only project root should be on sys.path
+    # Clean any existing direct package paths that could break package imports (e.g., 'MediLink' is not a package)
+    for pkg_dir in (os.path.join(workspace_root, 'MediBot'), os.path.join(workspace_root, 'MediLink')):
+        while pkg_dir in sys.path:
+            sys.path.remove(pkg_dir)
 
 def run_medibot(config_file=None):
     """Run MediBot application"""
     try:
         print("Starting MediBot...")
-        
-        # Set up command line arguments
+
+        # Resolve workspace root and MediBot.py path
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        workspace_root = os.path.dirname(current_dir)
+        medibot_path = os.path.join(workspace_root, 'MediBot', 'MediBot.py')
+
+        if not os.path.exists(medibot_path):
+            print("Error: MediBot.py not found at {}".format(medibot_path))
+            return 1
+
+        # Build subprocess arguments
+        args = [sys.executable, medibot_path]
         if config_file:
-            sys.argv = ['MediBot.py', config_file]
+            args.append(config_file)
+
+        # Ensure subprocess can import project packages
+        env = os.environ.copy()
+        python_path = workspace_root
+        if 'PYTHONPATH' in env:
+            env['PYTHONPATH'] = python_path + os.pathsep + env['PYTHONPATH']
         else:
-            sys.argv = ['MediBot.py']
-            
-        # Import and run MediBot directly
-        try:
-            from MediBot import MediBot
-            # If MediBot has a main function, call it
-            if hasattr(MediBot, 'main'):
-                return MediBot.main()
-            else:
-                # Otherwise, just import it (it will run its own code)
-                return 0
-        except ImportError:
-            # Fallback: try to run the file directly
-            import subprocess
-            medibot_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'MediBot', 'MediBot.py')
-            if os.path.exists(medibot_path):
-                # Use subprocess.call for Python 3.4.4 compatibility
-                result = subprocess.call([sys.executable, medibot_path] + sys.argv[1:], 
-                                       cwd=os.path.dirname(medibot_path))
-                return result
-            else:
-                raise ImportError("MediBot.py not found at {}".format(medibot_path))
-        
-    except ImportError as e:
-        print("Error: Unable to import MediBot: {}".format(e))
-        return 1
+            env['PYTHONPATH'] = python_path
+
+        # Run MediBot as a script so its __main__ block executes
+        result = subprocess.call(args, cwd=os.path.dirname(medibot_path), env=env)
+        return result
+
     except Exception as e:
         print("Error running MediBot: {}".format(e))
         return 1

{medicafe-0.250810.3 → medicafe-0.250810.5}/MediCafe/core_utils.py

@@ -10,16 +10,20 @@ import os, sys
 # Ensure proper path setup for imports
 # Get the project root directory (parent of MediCafe directory)
 project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-medilink_dir = os.path.join(project_dir, 'MediLink')
-medibot_dir = os.path.join(project_dir, 'MediBot')
 
-# Add paths in order of priority - project root first, then module directories
+# Only add project root to sys.path; do NOT add package directories directly
 if project_dir not in sys.path:
     sys.path.insert(0, project_dir)
-if medilink_dir not in sys.path:
-    sys.path.insert(0, medilink_dir)
-if medibot_dir not in sys.path:
-    sys.path.insert(0, medibot_dir)
+
+# Remove any direct package paths that may have been injected elsewhere
+_pkg_dirs = [os.path.join(project_dir, 'MediLink'), os.path.join(project_dir, 'MediBot')]
+for _p in list(sys.path):
+    if _p in _pkg_dirs:
+        try:
+            while _p in sys.path:
+                sys.path.remove(_p)
+        except Exception:
+            pass
 
 # Common constants and configurations
 DEFAULT_CONFIG_PATH = os.path.join(project_dir, 'json', 'config.json')
@@ -62,7 +66,7 @@ def setup_module_paths(file_path):
     project_dir = os.path.abspath(os.path.join(os.path.dirname(file_path), ".."))
     current_dir = os.path.abspath(os.path.dirname(file_path))
     
-    # Add paths in order of priority
+    # Add only project root and current module dir; avoid adding package dirs explicitly
     if project_dir not in sys.path:
         sys.path.insert(0, project_dir)
     if current_dir not in sys.path:

{medicafe-0.250810.3 → medicafe-0.250810.5}/PKG-INFO

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

{medicafe-0.250810.3 → medicafe-0.250810.5}/medicafe.egg-info/PKG-INFO

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

{medicafe-0.250810.3 → medicafe-0.250810.5}/setup.py

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