medicafe 0.250728.9__py3-none-any.whl → 0.250805.0__py3-none-any.whl

MediCafe/__main__.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""
+MediCafe Entry Point (__main__.py)
+
+This module serves as the main entry point for the MediCafe package.
+It can be called directly from the batch file and routes user choices
+to the appropriate sub-applications without adding interface layers.
+
+Usage:
+    python -m MediCafe <command> [args...]
+    
+Commands:
+    medibot [config_file]     - Run MediBot data entry automation
+    medilink                  - Run MediLink claims processing  
+    claims_status             - Run United Claims Status checker
+    deductible               - Run United Deductible checker
+    download_emails          - Run email download functionality
+    version                  - Show MediCafe version information
+    
+The entry point preserves user choices and navigational flow from the
+batch script without adding unnecessary interface layers.
+"""
+
+import sys
+import os
+import argparse
+import os
+
+# Set up module paths for proper imports
+def setup_entry_point_paths():
+    """Set up paths for the MediCafe entry point"""
+    # Get the parent directory (workspace root)
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    workspace_root = os.path.dirname(current_dir)
+    
+    # Add to Python path if not already present
+    workspace_str = workspace_root
+    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)
+
+def run_medibot(config_file=None):
+    """Run MediBot application"""
+    try:
+        print("Starting MediBot...")
+        
+        # Set up command line arguments
+        if config_file:
+            sys.argv = ['MediBot.py', config_file]
+        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
+    except Exception as e:
+        print("Error running MediBot: {}".format(e))
+        return 1
+
+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
+        
+    except ImportError as e:
+        print("Error: Unable to import MediLink: {}".format(e))
+        return 1
+    except Exception as e:
+        print("Error running MediLink: {}".format(e))
+        return 1
+
+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
+        
+    except ImportError as e:
+        print("Error: Unable to import MediLink_ClaimStatus: {}".format(e))
+        return 1
+    except Exception as e:
+        print("Error running Claims Status: {}".format(e))
+        return 1
+
+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
+        
+    except ImportError as e:
+        print("Error: Unable to import MediLink_Deductible: {}".format(e))
+        return 1
+    except Exception as e:
+        print("Error running Deductible checker: {}".format(e))
+        return 1
+
+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
+        
+    except ImportError as e:
+        print("Error: Unable to import MediLink_Gmail: {}".format(e))
+        return 1
+    except Exception as e:
+        print("Error running email download: {}".format(e))
+        return 1
+
+def show_version():
+    """Show MediCafe version information"""
+    try:
+        from MediCafe import __version__, __author__
+        print("MediCafe version {}".format(__version__))
+        print("Author: {}".format(__author__))
+        return 0
+    except ImportError:
+        print("MediCafe version information not available")
+        return 1
+
+def main():
+    """Main entry point for MediCafe"""
+    # Set up paths first
+    setup_entry_point_paths()
+    
+    # Create argument parser
+    parser = argparse.ArgumentParser(
+        description='MediCafe - Medical Practice Management Automation Suite',
+        prog='python -m MediCafe'
+    )
+    
+    parser.add_argument(
+        'command',
+        choices=['medibot', 'medilink', 'claims_status', 'deductible', 'download_emails', 'version'],
+        help='Command to execute'
+    )
+    
+    parser.add_argument(
+        'config_file',
+        nargs='?',
+        help='Configuration file path (for medibot command)'
+    )
+    
+    # Parse arguments
+    if len(sys.argv) < 2:
+        parser.print_help()
+        return 1
+        
+    args = parser.parse_args()
+    
+    # Route to appropriate function based on command
+    try:
+        if args.command == 'medibot':
+            return run_medibot(args.config_file)
+        elif args.command == 'medilink':
+            return run_medilink()
+        elif args.command == 'claims_status':
+            return run_claims_status()
+        elif args.command == 'deductible':
+            return run_deductible()
+        elif args.command == 'download_emails':
+            return run_download_emails()
+        elif args.command == 'version':
+            return show_version()
+        else:
+            print("Unknown command: {}".format(args.command))
+            parser.print_help()
+            return 1
+            
+    except KeyboardInterrupt:
+        print("\nOperation cancelled by user")
+        return 1
+    except Exception as e:
+        print("Unexpected error: {}".format(e))
+        return 1
+
+if __name__ == '__main__':
+    exit_code = main()
+    sys.exit(exit_code)