medicafe 0.250819.0__tar.gz → 0.250819.2__tar.gz

{medicafe-0.250819.0 → medicafe-0.250819.2}/MediBot/__init__.py

@@ -19,7 +19,7 @@ Smart Import Integration:
         medibot_main = get_components('medibot_main')
 """
 
-__version__ = "0.250819.0"
+__version__ = "0.250819.2"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

{medicafe-0.250819.0 → medicafe-0.250819.2}/MediCafe/MediLink_ConfigLoader.py

@@ -6,6 +6,7 @@ except ImportError:
     yaml = None
 from datetime import datetime
 from collections import OrderedDict
+from functools import reduce
 
 # Global configuration cache to prevent repeated loading
 _CONFIG_CACHE = None
@@ -166,6 +167,11 @@ def clear_config_cache():
     _CONFIG_CACHE = None
     _CROSSWALK_CACHE = None
         
+def require_config_value(key_path, use_cache=True):
+    # TODO This needs expanding a little bit but generally this type of functionality is good to have at this level.
+    config = _CONFIG_CACHE if use_cache and _CONFIG_CACHE else load_configuration()[0]
+    return reduce(lambda d, k: d[k], key_path.split('.'), config)
+
 # 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):
     

{medicafe-0.250819.0 → medicafe-0.250819.2}/MediCafe/__init__.py

@@ -27,7 +27,7 @@ Smart Import System:
         api_suite = get_api_access()
 """
 
-__version__ = "0.250819.0"
+__version__ = "0.250819.2"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

{medicafe-0.250819.0 → medicafe-0.250819.2}/MediLink/MediLink_837p_encoder_library.py

@@ -199,23 +199,23 @@ def create_nm1_billing_provider_segment(config, endpoint):
     billing_provider_entity_code = endpoint_config.get('billing_provider_entity_code', '85')
     billing_provider_npi_qualifier = endpoint_config.get('billing_provider_npi_qualifier', 'XX')
     # Resolve required values with TestMode-aware enforcement
-    billing_provider_lastname = require_config_value(
+    billing_provider_lastname = legacy_require_config_value(
         [config, endpoint_config],
-        'billing_provider_lastname',
-        config.get('default_billing_provider_name', 'DEFAULT NAME'),
+        ['billing_provider_lastname', 'default_billing_provider_name'],
+        'DEFAULT NAME',
         '2010AA Billing Provider Last Name',
         config,
         endpoint
     )
     billing_provider_firstname = config.get('billing_provider_firstname', '')
-    billing_provider_npi = require_config_value(
+    billing_provider_npi = legacy_require_config_value(
         [endpoint_config, config],
-        'billing_provider_npi',
-        config.get('default_billing_provider_npi', 'DEFAULT NPI'),
+        ['billing_provider_npi', 'default_billing_provider_npi'],
+        'DEFAULT NPI',
         '2010AA Billing Provider NPI',
         config,
         endpoint
-    )
+    ) # BUG This is stupid. The NPI is the same. Maybe the first and last name registration might vary by endpoint, but the NPI wont.
     
     # Determine billing_entity_type_qualifier based on the presence of billing_provider_firstname
     billing_entity_type_qualifier = '1' if billing_provider_firstname else '2' 
@@ -233,17 +233,17 @@ def create_nm1_billing_provider_segment(config, endpoint):
     # Construct address segments
     address_segments = []
     if config.get('billing_provider_address'):
-        addr = require_config_value([config], 'billing_provider_address', 'NO ADDRESS', '2010AA Billing Address', config, endpoint)
-        city = require_config_value([config], 'billing_provider_city', 'NO CITY', '2010AA Billing City', config, endpoint)
-        state = require_config_value([config], 'billing_provider_state', 'NO STATE', '2010AA Billing State', config, endpoint)
-        zip_code = require_config_value([config], 'billing_provider_zip', 'NO ZIP', '2010AA Billing ZIP', config, endpoint)
+        addr = legacy_require_config_value([config], 'billing_provider_address', 'NO ADDRESS', '2010AA Billing Address', config, endpoint)
+        city = legacy_require_config_value([config], 'billing_provider_city', 'NO CITY', '2010AA Billing City', config, endpoint)
+        state = legacy_require_config_value([config], 'billing_provider_state', 'NO STATE', '2010AA Billing State', config, endpoint)
+        zip_code = legacy_require_config_value([config], 'billing_provider_zip', 'NO ZIP', '2010AA Billing ZIP', config, endpoint)
         # N3 segment for address line
         address_segments.append("N3*{}~".format(addr))
         # N4 segment for City, State, ZIP
         address_segments.append("N4*{}*{}*{}~".format(city, state, zip_code))
     
     # Assuming Tax ID is part of the same loop, otherwise move REF segment to the correct loop
-    billing_tin = require_config_value([config], 'billing_provider_tin', 'NO TAX ID', '2010AA Billing TIN', config, endpoint)
+    billing_tin = legacy_require_config_value([config], 'billing_provider_tin', 'NO TAX ID', '2010AA Billing TIN', config, endpoint)
     ref_segment = "REF*EI*{}~".format(billing_tin)
     
     # Construct PRV segment if provider taxonomy is needed
@@ -265,12 +265,12 @@ def create_service_facility_location_npi_segment(config):
     Constructs segments for the service facility location, including the NM1 segment for identification
     and accompanying N3 and N4 segments for address details.
     """
-    facility_npi = require_config_value([config], 'service_facility_npi', 'DEFAULT FACILITY NPI', '2310C Service Facility NPI', config)
-    facility_name = require_config_value([config], 'service_facility_name', 'DEFAULT FACILITY NAME', '2310C Service Facility Name', config)
-    address_line_1 = require_config_value([config], 'service_facility_address', 'NO ADDRESS', '2310C Service Facility Address', config)
-    city = require_config_value([config], 'service_facility_city', 'NO CITY', '2310C Service Facility City', config)
-    state = require_config_value([config], 'service_facility_state', 'NO STATE', '2310C Service Facility State', config)
-    zip_code = require_config_value([config], 'service_facility_zip', 'NO ZIP', '2310C Service Facility ZIP', config)
+    facility_npi = legacy_require_config_value([config], 'service_facility_npi', 'DEFAULT FACILITY NPI', '2310C Service Facility NPI', config)
+    facility_name = legacy_require_config_value([config], 'service_facility_name', 'DEFAULT FACILITY NAME', '2310C Service Facility Name', config)
+    address_line_1 = legacy_require_config_value([config], 'service_facility_address', 'NO ADDRESS', '2310C Service Facility Address', config)
+    city = legacy_require_config_value([config], 'service_facility_city', 'NO CITY', '2310C Service Facility City', config)
+    state = legacy_require_config_value([config], 'service_facility_state', 'NO STATE', '2310C Service Facility State', config)
+    zip_code = legacy_require_config_value([config], 'service_facility_zip', 'NO ZIP', '2310C Service Facility ZIP', config)
 
     # NM1 segment for facility identification
     nm1_segment = "NM1*77*2*{}*****XX*{}~".format(facility_name, facility_npi)
@@ -290,20 +290,20 @@ def create_1000A_submitter_name_segment(patient_data, config, endpoint):
     submitter_id_qualifier = endpoint_config.get('submitter_id_qualifier', '46')  # '46' for ETIN or 'XX' for NPI
     
     # Required submitter name
-    submitter_name = require_config_value([endpoint_config, config], 'nm_103_value', 'DEFAULT NAME', '1000A Submitter Name', config, endpoint)
+    submitter_name = legacy_require_config_value([endpoint_config, config], 'nm_103_value', 'DEFAULT NAME', '1000A Submitter Name', config, endpoint)
     
     # Extract payer_id from patient_data
     payer_id = patient_data.get('payer_id', '')
     
     # Check if payer_id is Florida Blue (00590 or BCBSF) and assign submitter_id accordingly
     if payer_id in ['00590', 'BCBSF']:
-        submitter_id = require_config_value([endpoint_config], 'nm_109_bcbs', 'DEFAULT BCBSF ID', '1000A Submitter ID (BCBSF)', config, endpoint)
+        submitter_id = legacy_require_config_value([endpoint_config], 'nm_109_bcbsf', 'DEFAULT BCBSF ID', '1000A Submitter ID (BCBSF)', config, endpoint)
     else:
-        submitter_id = require_config_value([endpoint_config], 'nm_109_value', 'DEFAULT ID', '1000A Submitter ID', config, endpoint)
+        submitter_id = legacy_require_config_value([endpoint_config], 'nm_109_value', 'DEFAULT ID', '1000A Submitter ID', config, endpoint)
     
     # Submitter contact details (required)
-    contact_name = require_config_value([config], 'submitter_name', 'NONE', '1000A Submitter Contact Name', config, endpoint)
-    contact_telephone_number = require_config_value([config], 'submitter_tel', 'NONE', '1000A Submitter Contact Phone', config, endpoint)
+    contact_name = legacy_require_config_value([config], 'submitter_name', 'NONE', '1000A Submitter Contact Name', config, endpoint)
+    contact_telephone_number = legacy_require_config_value([config], 'submitter_tel', 'NONE', '1000A Submitter Contact Phone', config, endpoint)
     
     # Get submitter first name to determine entity type qualifier
     submitter_first_name = config.get('submitter_first_name', '')
@@ -333,8 +333,8 @@ def create_1000B_receiver_name_segment(config, endpoint):
     endpoint_config = config.get('endpoints', {}).get(endpoint.upper(), {})
     receiver_entity_code = '40'
     receiver_id_qualifier = endpoint_config.get('receiver_id_qualifier', '46')
-    receiver_name = require_config_value([endpoint_config], 'receiver_name', 'DEFAULT RECEIVER NAME', '1000B Receiver Name', config, endpoint)
-    receiver_edi = require_config_value([endpoint_config], 'receiver_edi', 'DEFAULT EDI', '1000B Receiver EDI', config, endpoint)
+    receiver_name = legacy_require_config_value([endpoint_config], 'receiver_name', 'DEFAULT RECEIVER NAME', '1000B Receiver Name', config, endpoint)
+    receiver_edi = legacy_require_config_value([endpoint_config], 'receiver_edi', 'DEFAULT EDI', '1000B Receiver EDI', config, endpoint)
     return "NM1*{entity_code}*2*{receiver_name}*****{id_qualifier}*{receiver_edi}~".format(
         entity_code=receiver_entity_code,
         receiver_name=receiver_name,
@@ -347,11 +347,11 @@ def create_nm1_payto_address_segments(config):
     Constructs the NM1 segment for the Pay-To Address, N3 for street address, and N4 for city, state, and ZIP.
     This is used if the Pay-To Address is different from the Billing Provider Address.
     """
-    payto_provider_name = require_config_value([config], 'payto_provider_name', 'DEFAULT PAY-TO NAME', '2010AB Pay-To Name', config)
-    payto_address = require_config_value([config], 'payto_address', 'DEFAULT PAY-TO ADDRESS', '2010AB Pay-To Address', config)
-    payto_city = require_config_value([config], 'payto_city', 'DEFAULT PAY-TO CITY', '2010AB Pay-To City', config)
-    payto_state = require_config_value([config], 'payto_state', 'DEFAULT PAY-TO STATE', '2010AB Pay-To State', config)
-    payto_zip = require_config_value([config], 'payto_zip', 'DEFAULT PAY-TO ZIP', '2010AB Pay-To ZIP', config)
+    payto_provider_name = legacy_require_config_value([config], 'payto_provider_name', 'DEFAULT PAY-TO NAME', '2010AB Pay-To Name', config)
+    payto_address = legacy_require_config_value([config], 'payto_address', 'DEFAULT PAY-TO ADDRESS', '2010AB Pay-To Address', config)
+    payto_city = legacy_require_config_value([config], 'payto_city', 'DEFAULT PAY-TO CITY', '2010AB Pay-To City', config)
+    payto_state = legacy_require_config_value([config], 'payto_state', 'DEFAULT PAY-TO STATE', '2010AB Pay-To State', config)
+    payto_zip = legacy_require_config_value([config], 'payto_zip', 'DEFAULT PAY-TO ZIP', '2010AB Pay-To ZIP', config)
     
     nm1_segment = "NM1*87*2*{}~".format(payto_provider_name)
     n3_segment = "N3*{}~".format(payto_address)
@@ -1528,37 +1528,47 @@ DEFAULT_PLACEHOLDER_VALUES = set([
     'NO STATE', 'NO ZIP', 'NO TAX ID', 'NONE'
 ])
 
-def _get_value_from_sources(source_dicts, key):
-    for d in source_dicts:
-        try:
-            if isinstance(d, dict) and key in d:
-                val = d.get(key)
-                if val not in [None, '']:
-                    return val
-        except Exception:
-            pass
+string_types = (str,)
+
+def _get_value_from_sources(source_dicts, keys):
+    # Accept a single key or an ordered list/tuple of keys; scan in priority order
+    if not isinstance(keys, (list, tuple)):
+        keys = [keys]
+    for key in keys:
+        for d in source_dicts:
+            try:
+                if isinstance(d, dict) and key in d:
+                    val = d.get(key)
+                    if val not in [None, '']:
+                        return val
+            except Exception:
+                pass
     return None
 
-def require_config_value(source_dicts, key, default_value, context_label, config, endpoint=None, allow_default_in_test=True):
+def legacy_require_config_value(source_dicts, key, default_value, context_label, config, endpoint=None, allow_default_in_test=True):
     """
     Fetch a configuration value from one or more dicts.
+    - `key` may be a string or a list/tuple of keys to try in order (primary, secondary, ...).
     - If found and equals a known placeholder, allow only in TestMode.
     - If missing, allow default only in TestMode (when allow_default_in_test is True).
     - Otherwise raise ValueError to prevent generating malformed 837p.
+    
+    TODO Eventually we should get this functionality into configloader in MediCafe so that we can use it in other places.
     """
     value = _get_value_from_sources(source_dicts, key)
+    key_label = key if isinstance(key, string_types) else "/".join([k for k in key if isinstance(k, string_types)])
     # Found a value
     if value not in [None, '']:
         if isinstance(value, str) and value in DEFAULT_PLACEHOLDER_VALUES:
             if _is_test_mode(config):
                 try:
-                    MediLink_ConfigLoader.log("TEST MODE: Placeholder used for {} -> {}".format(key, value), level="WARNING")
+                    MediLink_ConfigLoader.log("TEST MODE: Placeholder used for {} -> {}".format(key_label, value), level="WARNING")
                 except Exception:
                     pass
-                print("TEST MODE: Using placeholder '{}' for {} ({})".format(value, key, context_label))
+                print("TEST MODE: Using placeholder '{}' for {} ({})".format(value, key_label, context_label))
                 return value
             else:
-                msg = "Missing real value for '{}' in {}. Found placeholder '{}'. Endpoint: {}".format(key, context_label, value, (endpoint or ''))
+                msg = "Missing real value for '{}' in {}. Found placeholder '{}'. Endpoint: {}".format(key_label, context_label, value, (endpoint or ''))
                 try:
                     MediLink_ConfigLoader.log(msg, level="CRITICAL")
                 except Exception:
@@ -1568,12 +1578,12 @@ def require_config_value(source_dicts, key, default_value, context_label, config
     # Missing value entirely
     if allow_default_in_test and _is_test_mode(config):
         try:
-            MediLink_ConfigLoader.log("TEST MODE: Default used for {} -> {}".format(key, default_value), level="WARNING")
+            MediLink_ConfigLoader.log("TEST MODE: Default used for {} -> {}".format(key_label, default_value), level="WARNING")
         except Exception:
             pass
-        print("TEST MODE: Using default '{}' for {} ({})".format(default_value, key, context_label))
+        print("TEST MODE: Using default '{}' for {} ({})".format(default_value, key_label, context_label))
         return default_value
-    msg = "Required configuration '{}' missing for {}. Endpoint: {}".format(key, context_label, (endpoint or ''))
+    msg = "Required configuration '{}' missing for {}. Endpoint: {}".format(key_label, context_label, (endpoint or ''))
     try:
         MediLink_ConfigLoader.log(msg, level="CRITICAL")
     except Exception:

{medicafe-0.250819.0 → medicafe-0.250819.2}/MediLink/MediLink_main.py

@@ -34,13 +34,6 @@ import MediLink_PatientProcessor  # Import patient processing functions
 # Use core utilities for standardized config loader
 MediLink_ConfigLoader = get_shared_config_loader()
 
-try:
-    from tqdm import tqdm
-except ImportError:
-    # Fallback for when tqdm is not available
-    def tqdm(iterable, **kwargs):
-        return iterable
-
 import_time = time.time()
 if PERFORMANCE_LOGGING:
     print("Import phase completed in {:.2f} seconds".format(import_time - start_time))
@@ -92,8 +85,8 @@ def main_menu():
     Initializes the main menu loop and handles the overall program flow,
     including loading configurations and managing user input for menu selections.
     """
+    global _last_ack_updated_at, _scheduled_ack_checks
     menu_start_time = time.time()
-    print("Main menu function started...")
     
     # Load configuration settings and display the initial welcome message.
     config_start_time = time.time()
@@ -149,6 +142,13 @@ def main_menu():
         ack_result = False
         pass
 
+    # TODO: Once we start building out the whole submission tracking persist structure,
+    # this boot-time scan should check when the last acknowledgement check was run
+    # and skip if it was run recently (e.g., within the last day) to avoid
+    # constantly running it on every startup. The submission tracking system should
+    # store the timestamp of the last successful acknowledgement check and use it
+    # to determine if a new scan is needed.
+
     # Clear screen before showing menu header
     try:
         os.system('cls' if os.name == 'nt' else 'clear')
@@ -204,27 +204,7 @@ def main_menu():
     if PERFORMANCE_LOGGING:
         print("Main menu initialization completed in {:.2f} seconds".format(menu_init_end - menu_start_time))
 
-    # Validate the calculated date range
-    try:
-        from datetime import datetime, timedelta
-        current_date = datetime.now()
-        start_date = current_date - timedelta(days=15)  # Default to 15-day range
-        end_date = current_date - timedelta(days=1)
-        def validate_date_range(start_date, end_date):
-            if start_date > end_date:
-                raise ValueError("Start date cannot be after end date.")
-            if start_date < (current_date - timedelta(days=30)): # Ensure it's not too far in the past
-                raise ValueError("Start date must be within the last 30 days.")
-            if end_date < (current_date - timedelta(days=30)): # Ensure it's not too far in the past
-                raise ValueError("End date must be within the last 30 days.")
-    except ImportError:
-        print("Date validation requires the 'datetime' module. Please ensure it's installed.")
-        # Fallback to a safe date range within 30 days
-        end_date = current_date - timedelta(days=1)
-        start_date = end_date - timedelta(days=15)  # 15-day range as fallback
-
-    end_date_str = end_date.strftime('%m/%d/%Y')
-    start_date_str = start_date.strftime('%m/%d/%Y')
+    
 
     while True:
         # Run any due scheduled ack checks before showing menu
@@ -294,7 +274,7 @@ def main_menu():
             
             # UX hint: suggest deeper United details
             try:
-                print("Tip: For United details, run the United Claims Status option for the same date window.")
+                print("Tip: For United details, run the United Claims Status checker.")
             except Exception:
                 pass
         elif choice == '2':
@@ -335,20 +315,6 @@ def main_menu():
             break
         elif choice == '4':
             _tools_menu(config, medi)
-        elif choice.lower() == 'tools:index':
-            # Optional maintenance: rebuild submission index now (synchronous)
-            try:
-                receipts_root = medi.get('local_claims_path', None)
-                if not receipts_root:
-                    print("No receipts folder configured.")
-                    continue
-                from MediCafe.submission_index import build_initial_index
-                receipts_root = os.path.normpath(receipts_root)
-                print("Rebuilding submission index... (this may take a while)")
-                count = build_initial_index(receipts_root)
-                print("Index rebuild complete. Indexed {} records.".format(count))
-            except Exception as e:
-                print("Index rebuild error: {}".format(e))
         else:
             # Display an error message if the user's choice does not match any valid option.
             MediLink_UI.display_invalid_choice()

{medicafe-0.250819.0 → medicafe-0.250819.2}/MediLink/__init__.py

@@ -22,7 +22,7 @@ Smart Import Integration:
         datamgmt = get_components('medilink_datamgmt')
 """
 
-__version__ = "0.250819.0"
+__version__ = "0.250819.2"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

{medicafe-0.250819.0 → medicafe-0.250819.2}/PKG-INFO

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

{medicafe-0.250819.0 → medicafe-0.250819.2}/medicafe.egg-info/PKG-INFO

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

{medicafe-0.250819.0 → medicafe-0.250819.2}/setup.py

@@ -54,7 +54,7 @@ if long_description_text is None:
 
 setup(
     name='medicafe',
-    version="0.250819.0",
+    version="0.250819.2",
     description='MediCafe',
     long_description=long_description_text,
     long_description_content_type='text/markdown',