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

MediBot/__init__.py

@@ -0,0 +1,89 @@
+# MediBot package
+"""
+MediBot - Medical Practice Data Entry Automation
+
+MediBot provides automated data entry capabilities for medical practice
+management systems, with focus on Medisoft automation.
+
+Smart Import Integration:
+    Instead of importing MediBot modules directly, use the MediCafe smart
+    import system for better dependency management and to avoid circular imports.
+    
+    Examples:
+        # Get everything for MediBot preprocessor work
+        from MediCafe import setup_for_medibot
+        components = setup_for_medibot('medibot_preprocessor')
+        
+        # Get specific MediBot components
+        from MediCafe import get_components
+        medibot_main = get_components('medibot_main')
+"""
+
+__version__ = "0.250728.9"
+__author__ = "Daniel Vidaud"
+__email__ = "daniel@personalizedtransformation.com"
+
+# Provide information about smart import integration
+def get_smart_import_info():
+    """Get information about using MediBot with the smart import system."""
+    return {
+        'recommended_approach': 'Use MediCafe smart import system',
+        'setup_function': 'setup_for_medibot(module_type)',
+        'available_module_types': [
+            'medibot_preprocessor',
+            'medibot_ui', 
+            'medibot_crosswalk',
+            'medibot_document_processing'
+        ],
+        'example': """
+# Recommended usage:
+from MediCafe import setup_for_medibot
+components = setup_for_medibot('medibot_preprocessor')
+
+# Access components:
+api_core = components.get('api_core')
+logging_config = components.get('logging_config')
+preprocessor_lib = components.get('medibot_preprocessor_lib')
+"""
+    }
+
+# Show smart import guide
+def show_smart_import_guide():
+    """Display a guide for using MediBot with smart imports."""
+    info = get_smart_import_info()
+    print("MediBot Smart Import Guide")
+    print("=" * 40)
+    print("Recommended approach: {}".format(info['recommended_approach']))
+    print("Setup function: {}".format(info['setup_function']))
+    print("\nAvailable module types:")
+    for module_type in info['available_module_types']:
+        print("  - {}".format(module_type))
+    print("\nExample usage:\n{}".format(info['example']))
+
+# Legacy import warning
+def _show_legacy_warning():
+    """Show a warning about direct imports."""
+    import warnings
+    warnings.warn(
+        "Direct MediBot imports may cause circular dependencies. "
+        "Consider using 'from MediCafe import setup_for_medibot' instead.",
+        FutureWarning,
+        stacklevel=3
+    )
+
+# Package metadata
+__all__ = [
+    '__version__',
+    '__author__', 
+    '__email__',
+    'get_smart_import_info',
+    'show_smart_import_guide'
+]
+
+# Optional: Show guide on import (can be disabled)
+import os
+if os.environ.get('MEDIBOT_SHOW_SMART_IMPORT_GUIDE', '').lower() == 'true':
+    try:
+        show_smart_import_guide()
+    except:
+        pass

MediBot/get_medicafe_version.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+MediCafe Version Detection Script
+Compatible with Python 3.4.4 and Windows XP
+"""
+
+import sys
+import pkg_resources
+
+def get_medicafe_version():
+    """Get the installed MediCafe package version."""
+    try:
+        version = pkg_resources.get_distribution('medicafe').version
+        print('MediCafe=={}'.format(version))
+        return 0
+    except pkg_resources.DistributionNotFound:
+        print('MediCafe package not found', file=sys.stderr)
+        return 1
+    except Exception as e:
+        print('Error detecting MediCafe version: {}'.format(e), file=sys.stderr)
+        return 1
+
+if __name__ == '__main__':
+    sys.exit(get_medicafe_version()) 

MediBot/update_json.py

@@ -1,6 +1,7 @@
 # update_json.py
 import json
 import sys
+import os
 from collections import OrderedDict
 
 def get_current_csv_path(json_file):
@@ -20,6 +21,32 @@ def get_current_csv_path(json_file):
         sys.exit(1)
     return None
 
+def normalize_path_for_json(path):
+    """
+    Normalize a file path for JSON storage, ensuring proper backslash escaping.
+    This function prevents double-processing and ensures consistent formatting.
+    """
+    if not path:
+        return path
+    
+    # First, normalize the path using os.path to handle any existing issues
+    normalized_path = os.path.normpath(path)
+    
+    # Check if the path is already properly formatted for JSON (contains \\\\)
+    # We look for the pattern where backslashes are already escaped
+    if "\\\\" in normalized_path:
+        # Path is already JSON-formatted, return as-is
+        return normalized_path
+    
+    # Check if the path contains single backslashes that need escaping
+    if "\\" in normalized_path:
+        # Escape single backslashes for JSON
+        formatted_path = normalized_path.replace("\\", "\\\\")
+        return formatted_path
+    
+    # No backslashes found, return as-is
+    return normalized_path
+
 def update_csv_path(json_file, new_path):
     try:
         with open(json_file, 'r', encoding='utf-8') as file:
@@ -29,12 +56,14 @@ def update_csv_path(json_file, new_path):
                 print("Error decoding JSON file '{}': {}".format(json_file, decode_err))
                 sys.exit(1)
 
-        # Ensure correct backslash formatting for JSON
-        if "\\" in new_path and "\\\\" not in new_path:
-            formatted_path = new_path.replace("\\", "\\\\")
-        else:
-            formatted_path = new_path
-
+        # Use the improved path normalization function
+        formatted_path = normalize_path_for_json(new_path)
+        
+        # Validate that the path doesn't have excessive slashes
+        if formatted_path.count("\\\\") > formatted_path.count("\\") * 2:
+            print("Warning: Path may have excessive backslashes. Original: {}, Formatted: {}".format(
+                new_path, formatted_path))
+        
         data['CSV_FILE_PATH'] = formatted_path
 
         with open(json_file, 'w', encoding='utf-8') as file:

MediBot/update_medicafe.py

@@ -1,5 +1,19 @@
 #update_medicafe.py
-import subprocess, sys, requests, time, pkg_resources, platform
+import subprocess, sys, time, platform
+
+# Safe import for pkg_resources with fallback
+try:
+    import pkg_resources
+except ImportError:
+    pkg_resources = None
+    print("Warning: pkg_resources not available. Some functionality may be limited.")
+
+# Safe import for requests with fallback
+try:
+    import requests
+except ImportError:
+    requests = None
+    print("Warning: requests module not available. Some functionality may be limited.")
 
 def get_installed_version(package):
     try:
@@ -22,6 +36,10 @@ def get_latest_version(package, retries=3, delay=1):
     """
     Fetch the latest version of the specified package from PyPI with retries.
     """
+    if not requests:
+        print("Error: requests module not available. Cannot fetch latest version.")
+        return None
+        
     for attempt in range(1, retries + 1):
         try:
             response = requests.get("https://pypi.org/pypi/{}/json".format(package), timeout=10)

MediCafe/MediLink_ConfigLoader.py

@@ -0,0 +1,160 @@
+# MediLink_ConfigLoader.py
+import os, json, logging, sys, platform
+try:
+    import yaml
+except ImportError:
+    yaml = None
+from datetime import datetime
+from collections import OrderedDict
+
+# Global configuration cache to prevent repeated loading
+_CONFIG_CACHE = None
+_CROSSWALK_CACHE = None
+
+# Import centralized logging configuration
+try:
+    from MediCafe.logging_config import PERFORMANCE_LOGGING
+except ImportError:
+    # Fallback to local flag if centralized config is not available
+    PERFORMANCE_LOGGING = False
+
+"""
+This function should be generalizable to have a initialization script over all the Medi* functions
+"""
+def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..', 'json', 'config.json'), crosswalk_path=os.path.join(os.path.dirname(__file__), '..', 'json', 'crosswalk.json')):
+    """
+    Loads endpoint configuration, credentials, and other settings from JSON or YAML files.
+        
+    Returns: A tuple containing dictionaries with configuration settings for the main config and crosswalk.
+    """
+    global _CONFIG_CACHE, _CROSSWALK_CACHE
+    
+    # Return cached configuration if available
+    if _CONFIG_CACHE is not None and _CROSSWALK_CACHE is not None:
+        return _CONFIG_CACHE, _CROSSWALK_CACHE
+    
+    import time
+    config_start = time.time()
+    if PERFORMANCE_LOGGING:
+        print("Configuration loading started...")
+    
+    # TODO (Low Config Upgrade) The Medicare / Private differentiator flag probably needs to be pulled or passed to this.
+    # Use provided paths, or fall back to platform-specific defaults
+    path_check_start = time.time()
+    if not os.path.exists(config_path):
+        # Try platform-specific paths as fallback
+        if platform.system() == 'Windows' and platform.release() == 'XP':
+            # Use F: paths for Windows XP
+            config_path = "F:\\Medibot\\json\\config.json"
+            crosswalk_path = "G:\\My Drive\\Codes\\MediCafe\\json\\crosswalk.json"
+        elif platform.system() == 'Windows':
+            # Use G: paths for other versions of Windows
+            config_path = "G:\\My Drive\\Codes\\MediCafe\\json\\config.json"
+            crosswalk_path = "G:\\My Drive\\Codes\\MediCafe\\json\\crosswalk.json"
+        # If not Windows or if local files don't exist, keep the default paths
+    
+    path_check_end = time.time()
+    if PERFORMANCE_LOGGING:
+        print("Path resolution completed in {:.2f} seconds".format(path_check_end - path_check_start))
+    
+    try:
+        config_load_start = time.time()
+        with open(config_path, 'r') as config_file:
+            if config_path.endswith('.yaml') or config_path.endswith('.yml'):
+                config = yaml.safe_load(config_file)
+            elif config_path.endswith('.json'):
+                config = json.load(config_file, object_pairs_hook=OrderedDict)
+            else:
+                raise ValueError("Unsupported configuration format.")
+            
+            if 'MediLink_Config' not in config:
+                raise KeyError("MediLink_Config key is missing from the loaded configuration.")
+        
+        config_load_end = time.time()
+        if PERFORMANCE_LOGGING:
+            print("Config file loading completed in {:.2f} seconds".format(config_load_end - config_load_start))
+
+        crosswalk_load_start = time.time()
+        with open(crosswalk_path, 'r') as crosswalk_file:
+            crosswalk = json.load(crosswalk_file)
+        crosswalk_load_end = time.time()
+        if PERFORMANCE_LOGGING:
+            print("Crosswalk file loading completed in {:.2f} seconds".format(crosswalk_load_end - crosswalk_load_start))
+
+        config_end = time.time()
+        if PERFORMANCE_LOGGING:
+            print("Total configuration loading completed in {:.2f} seconds".format(config_end - config_start))
+        
+        # Cache the loaded configuration
+        _CONFIG_CACHE = config
+        _CROSSWALK_CACHE = crosswalk
+        
+        return config, crosswalk
+    except ValueError as e:
+        if isinstance(e, UnicodeDecodeError):
+            print("Error decoding file: {}".format(e))
+        else:
+            print("Error parsing file: {}".format(e))
+        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
+    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
+    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
+
+def clear_config_cache():
+    """Clear the configuration cache to force reloading on next call."""
+    global _CONFIG_CACHE, _CROSSWALK_CACHE
+    _CONFIG_CACHE = None
+    _CROSSWALK_CACHE = None
+        
+# Logs messages with optional error type and claim data.
+def log(message, config=None, level="INFO", error_type=None, claim=None, verbose=False, console_output=False):
+    
+    # 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
+    
+    # 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 '.'
+        log_filename = datetime.now().strftime("Log_%m%d%Y.log")
+        log_filepath = os.path.join(local_storage_path, log_filename)
+        
+        # Set logging level based on verbosity
+        logging_level = logging.DEBUG if verbose else logging.INFO
+        
+        # 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]
+        
+        # Add console handler only if console_output is True
+        if console_output:
+            console_handler = logging.StreamHandler()
+            console_handler.setFormatter(formatter)
+            handlers.append(console_handler)
+        
+        # Configure root logger
+        logging.basicConfig(level=logging_level, handlers=handlers)
+    
+    # Prepare log message
+    claim_data = " - Claim Data: {}".format(claim) if claim else ""
+    error_info = " - Error Type: {}".format(error_type) if error_type else ""
+    full_message = "{} {}{}".format(message, claim_data, error_info)
+
+    # Log the message
+    logger = logging.getLogger()
+    getattr(logger, level.lower())(full_message)

MediCafe/__init__.py

@@ -0,0 +1,171 @@
+# MediCafe package
+"""
+MediCafe - Medical Practice Management Automation Suite
+
+A comprehensive suite for automating medical administrative tasks in Medisoft.
+Includes MediBot for data entry automation and MediLink for claims processing.
+
+Smart Import System:
+    The MediCafe package now includes a smart import system that provides
+    centralized component management for all MediBot and MediLink modules.
+    
+    Quick Start:
+        # Get specific components
+        from MediCafe import get_components
+        api_core, logging_config = get_components('api_core', 'logging_config')
+        
+        # Setup for MediBot
+        from MediCafe import setup_for_medibot
+        components = setup_for_medibot('medibot_preprocessor')
+        
+        # Setup for MediLink  
+        from MediCafe import setup_for_medilink
+        components = setup_for_medilink('medilink_main')
+        
+        # Get complete API access
+        from MediCafe import get_api_access
+        api_suite = get_api_access()
+"""
+
+__version__ = "0.250728.9"
+__author__ = "Daniel Vidaud"
+__email__ = "daniel@personalizedtransformation.com"
+
+# Import and expose the smart import system
+try:
+    from .smart_import import (
+        # Main interface
+        get_components,
+        
+        # Convenience functions
+        get_api_access,
+        get_logging,
+        get_core_utils,
+        setup_for_medibot,
+        setup_for_medilink,
+        
+        # Discovery functions
+        list_components,
+        list_module_types,
+        describe_module_type,
+        
+        # Validation and utilities
+        validate_setup,
+        show_usage_examples
+    )
+    
+    # Mark smart import system as available
+    __smart_import_available__ = True
+    
+except ImportError as e:
+    # Fallback if smart import system is not available
+    __smart_import_available__ = False
+    
+    def _smart_import_unavailable(*args, **kwargs):
+        raise ImportError("MediCafe Smart Import System is not available: {}".format(e))
+    
+    # Provide error functions for missing imports
+    get_components = _smart_import_unavailable
+    get_api_access = _smart_import_unavailable
+    get_logging = _smart_import_unavailable
+    get_core_utils = _smart_import_unavailable
+    setup_for_medibot = _smart_import_unavailable
+    setup_for_medilink = _smart_import_unavailable
+    list_components = _smart_import_unavailable
+    list_module_types = _smart_import_unavailable
+    describe_module_type = _smart_import_unavailable
+    validate_setup = _smart_import_unavailable
+    show_usage_examples = _smart_import_unavailable
+
+# Legacy imports for backward compatibility
+try:
+    from . import api_core
+    from . import logging_config
+    from . import core_utils
+    __legacy_imports_available__ = True
+except ImportError:
+    __legacy_imports_available__ = False
+
+# Package information
+__all__ = [
+    # Smart import system
+    'get_components',
+    'get_api_access', 
+    'get_logging',
+    'get_core_utils',
+    'setup_for_medibot',
+    'setup_for_medilink',
+    'list_components',
+    'list_module_types', 
+    'describe_module_type',
+    'validate_setup',
+    'show_usage_examples',
+    
+    # Package metadata
+    '__version__',
+    '__author__',
+    '__email__',
+    '__smart_import_available__',
+    '__legacy_imports_available__'
+]
+
+def get_package_info():
+    """Get information about the MediCafe package and its capabilities."""
+    info = {
+        'version': __version__,
+        'author': __author__,
+        'email': __email__,
+        'smart_import_available': __smart_import_available__,
+        'legacy_imports_available': __legacy_imports_available__
+    }
+    
+    if __smart_import_available__:
+        try:
+            info['available_components'] = len(list_components())
+            info['available_module_types'] = len(list_module_types())
+        except:
+            info['available_components'] = 'unknown'
+            info['available_module_types'] = 'unknown'
+    
+    return info
+
+def quick_start_guide():
+    """Display a quick start guide for using MediCafe."""
+    guide = """
+    MediCafe Quick Start Guide
+    =========================
+    
+    1. Basic Usage - Get specific components:
+       from MediCafe import get_components
+       api_core, logging = get_components('api_core', 'logging_config')
+    
+    2. MediBot Setup - Get everything for MediBot:
+       from MediCafe import setup_for_medibot
+       components = setup_for_medibot('medibot_preprocessor')
+       
+    3. MediLink Setup - Get everything for MediLink:
+       from MediCafe import setup_for_medilink  
+       components = setup_for_medilink('medilink_main')
+       
+    4. API Access - Get complete API suite:
+       from MediCafe import get_api_access
+       api_suite = get_api_access()
+       
+    5. Discovery - See what's available:
+       from MediCafe import list_components, list_module_types
+       print("Components:", list_components())
+       print("Module types:", list_module_types())
+    
+    6. Validation - Test the system:
+       from MediCafe import validate_setup
+       validate_setup()
+    """
+    print(guide)
+
+# Auto-validation message (only if smart import is available)
+if __smart_import_available__:
+    try:
+        # Silent validation on package import
+        pass
+    except:
+        pass