medicafe 0.250822.2__py3-none-any.whl → 0.250909.0__py3-none-any.whl

MediBot/MediBot_docx_decoder.py

@@ -80,7 +80,7 @@ _DAY_MAP = {
 }
 
 
-def parse_docx(filepath, surgery_dates):  # Accept surgery_dates as a parameter
+def parse_docx(filepath, surgery_dates, capture_schedule_positions=False):  # Accept surgery_dates as a parameter
     if Document is None:
         MediLink_ConfigLoader.log("docx module not available, cannot parse .docx files", level="WARNING")
         return {}
@@ -99,6 +99,7 @@ def parse_docx(filepath, surgery_dates):  # Accept surgery_dates as a parameter
         return {}
 
     patient_data = OrderedDict()  # Initialize OrderedDict to store data
+    schedule_positions = {}  # NEW: Track patient order in schedule
     MediLink_ConfigLoader.log("Extracting Date of Service from {}".format(filepath), level="DEBUG")
     
     # TIMING: Start date extraction
@@ -134,7 +135,7 @@ def parse_docx(filepath, surgery_dates):  # Accept surgery_dates as a parameter
 
     for table in doc.tables:  # Iterate over tables in the document
         tables_processed += 1
-        for row in table.rows:
+        for row_idx, row in enumerate(table.rows):
             rows_processed += 1
             cells = [cell.text.strip() for cell in row.cells]
             if len(cells) > 4 and cells[3].startswith('#'):
@@ -152,6 +153,12 @@ def parse_docx(filepath, surgery_dates):  # Accept surgery_dates as a parameter
                         MediLink_ConfigLoader.log("Duplicate entry for patient ID {} on date {}. Skipping.".format(patient_id, date_of_service), level="WARNING")
                     else:
                         patient_data[patient_id][date_of_service] = [diagnosis_code, left_or_right_eye, femto_yes_or_no]
+                        
+                        # NEW: Store schedule position if requested
+                        if capture_schedule_positions:
+                            if patient_id not in schedule_positions:
+                                schedule_positions[patient_id] = {}
+                            schedule_positions[patient_id][date_of_service] = row_idx
                 except Exception as e:
                     MediLink_ConfigLoader.log("Error processing row: {}. Error: {}".format(cells, e), level="ERROR")
     
@@ -183,7 +190,11 @@ def parse_docx(filepath, surgery_dates):  # Accept surgery_dates as a parameter
         print("      * Validation: {:.3f}s".format(validation_duration))
         print("      * Total: {:.3f}s".format(total_duration))
     
-    return patient_data
+    # Return both data structures if schedule positions were captured
+    if capture_schedule_positions:
+        return patient_data, schedule_positions
+    else:
+        return patient_data
 
 
 def validate_unknown_entries(patient_data):

MediBot/__init__.py

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

MediCafe/MediLink_ConfigLoader.py

@@ -32,7 +32,18 @@ def get_default_config():
             'logging': {
                 'level': 'INFO',
                 'console_output': True
-            }
+            },
+            # STRATEGIC NOTE (COB Configuration): COB library is fully implemented and ready
+            # To enable COB functionality, add the following configuration:
+            # 'cob_settings': {
+            #     'enabled': False,  # Set to True to activate COB processing
+            #     'medicare_payer_ids': ['00850', 'MEDICARE', 'CMS', 'MCARE'],
+            #     'cob_mode': 'single_payer_only',  # or 'multi_payer_supported'
+            #     'validation_level': 3,  # SNIP level 3+ recommended for COB
+            #     'medicare_advantage_identifiers': ['MA', 'MC'],
+            #     'default_medicare_type': 'MB',
+            #     'require_835_validation': False  # Set True for production
+            # }
         }
     }
 

MediCafe/__init__.py

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

MediCafe/api_core.py

@@ -118,10 +118,107 @@ except ImportError:
     class TokenCache:
         def __init__(self):
             self.tokens = {}
-        def get(self, endpoint_name, current_time):
-            return None
-        def set(self, endpoint_name, access_token, expires_in, current_time):
-            pass
+
+# -----------------------------------------------------------------------------
+# Endpoint-specific payer ID management (crosswalk-backed with hardcoded default)
+# -----------------------------------------------------------------------------
+# Intent:
+# - Validate payer IDs against the endpoint actually being called.
+# - Persist endpoint-specific payer ID lists into the crosswalk so they can be
+#   updated over time without changing code.
+# - For OPTUMAI: use the augmented list (includes LIFE1, WELM2, etc.).
+# - For UHCAPI (including its Super Connector fallback): strictly enforce the
+#   known-good UHC payer IDs only.
+# - Future: OPTUMAI will expose a dedicated endpoint that returns its current
+#   valid payer list. When available, this function should fetch and refresh the
+#   crosswalk entry automatically (likely weekly/monthly), replacing the
+#   hardcoded default below. The UHCAPI Super Connector will eventually be
+#   deprecated; when removed, cleanup the UHC-specific paths accordingly.
+
+try:
+    # Prefer using existing crosswalk persistence utilities
+    from MediBot.MediBot_Crosswalk_Utils import ensure_full_config_loaded, save_crosswalk
+except Exception:
+    ensure_full_config_loaded = None
+    save_crosswalk = None
+
+def _get_default_endpoint_payer_ids(endpoint_name):
+    """
+    Return hardcoded default payer IDs for a given endpoint.
+
+    NOTE: Defaults are used when crosswalk does not yet contain a list.
+    """
+    # UHC-only list – keep STRICT. Do not augment with non-UHC payers.
+    uhc_payer_ids = [
+        "87726", "03432", "96385", "95467", "86050", "86047", "95378", "06111", "37602"
+    ]
+
+    # OPTUMAI – augmented list (subject to growth once the API adds a payer-list endpoint)
+    optumai_payer_ids = [
+        "87726", "06111", "25463", "37602", "39026", "74227", "65088", "81400",
+        "03432", "86050", "86047", "95378", "95467", "LIFE1", "WELM2"
+    ]
+
+    if endpoint_name == 'OPTUMAI':
+        return optumai_payer_ids
+    # Default to UHCAPI for any other endpoint name
+    return uhc_payer_ids
+
+def get_valid_payer_ids_for_endpoint(client, endpoint_name):
+    """
+    Resolve the valid payer IDs for a specific endpoint using crosswalk storage
+    with a safe fallback to hardcoded defaults.
+
+    Behavior:
+    - Attempts to read crosswalk['endpoint_payer_ids'][endpoint_name].
+    - If missing, initializes with hardcoded defaults and persists to crosswalk
+      (non-interactive) so that future sessions use the saved list.
+    - Future: For OPTUMAI, replace the hardcoded default by calling the API's
+      payer-list endpoint once available, then update the crosswalk.
+    """
+    try:
+        # Load full config + crosswalk (non-destructive)
+        base_config = None
+        crosswalk = None
+        if ensure_full_config_loaded is not None:
+            base_config, crosswalk = ensure_full_config_loaded(
+                getattr(client, 'config', None),
+                getattr(client, 'crosswalk', None)
+            )
+        else:
+            # Fallback: attempt to load via MediLink_ConfigLoader directly
+            # If we reach this fallback, it means ensure_full_config_loaded is not available.
+            # This is unexpected in normal operation and should be alerted.
+            print("Warning: IN api_core, ensure_full_config_loaded is not available; falling back to MediLink_ConfigLoader.load_configuration().")
+            MediLink_ConfigLoader.log(
+                "Fallback: ensure_full_config_loaded not available in get_valid_payer_ids_for_endpoint; using MediLink_ConfigLoader.load_configuration().",
+                level="WARNING"
+            )
+            base_config, crosswalk = MediLink_ConfigLoader.load_configuration()
+
+        # Extract any existing stored list
+        cw_ep = crosswalk.get('endpoint_payer_ids', {}) if isinstance(crosswalk, dict) else {}
+        existing = cw_ep.get(endpoint_name)
+        if isinstance(existing, list) and len(existing) > 0:
+            return existing
+
+        # Initialize from defaults and persist to crosswalk
+        defaults = _get_default_endpoint_payer_ids(endpoint_name)
+        if isinstance(crosswalk, dict):
+            if 'endpoint_payer_ids' not in crosswalk:
+                crosswalk['endpoint_payer_ids'] = {}
+            crosswalk['endpoint_payer_ids'][endpoint_name] = list(defaults)
+
+            # Persist without interactive prompts; ignore errors silently to avoid breaking flows
+            if save_crosswalk is not None:
+                try:
+                    save_crosswalk(client, base_config, crosswalk, skip_api_operations=True)
+                except Exception:
+                    pass
+        return defaults
+    except Exception:
+        # As a last resort, return a safe default for the endpoint
+        return _get_default_endpoint_payer_ids(endpoint_name)
 
 class BaseAPIClient:
     def __init__(self, config):
@@ -792,12 +889,14 @@ def get_eligibility_v3(client, payer_id, provider_last_name, search_option, date
     if not all([client, payer_id, provider_last_name, search_option, date_of_birth, member_id, npi]):
         raise ValueError("All required parameters must have values: client, payer_id, provider_last_name, search_option, date_of_birth, member_id, npi")
 
-    # Validate payer_id
-    valid_payer_ids = ["87726", "06111", "25463", "37602", "39026", "74227", "65088", "81400", "03432", "86050", "86047", "95378", "95467"]
-    if payer_id not in valid_payer_ids:
-        raise ValueError("Invalid payer_id: {}. Must be one of: {}".format(payer_id, ", ".join(valid_payer_ids)))
-    
+    # Endpoint is UHCAPI for this v3 REST call
     endpoint_name = 'UHCAPI'
+
+    # Validate payer_id strictly against UHC list
+    valid_payer_ids = get_valid_payer_ids_for_endpoint(client, endpoint_name)
+    if payer_id not in valid_payer_ids:
+        raise ValueError("Invalid payer_id: {} for endpoint {}. Must be one of: {}".format(
+            payer_id, endpoint_name, ", ".join(valid_payer_ids)))
     from MediCafe.core_utils import extract_medilink_config
     medi = extract_medilink_config(client.config)
     url_extension = medi.get('endpoints', {}).get(endpoint_name, {}).get('additional_endpoints', {}).get('eligibility_v3', '')
@@ -856,11 +955,6 @@ def get_eligibility_super_connector(client, payer_id, provider_last_name, search
     if not all([client, payer_id, provider_last_name, search_option, date_of_birth, member_id, npi]):
         raise ValueError("All required parameters must have values: client, payer_id, provider_last_name, search_option, date_of_birth, member_id, npi")
 
-    # Validate payer_id
-    valid_payer_ids = ["87726", "06111", "25463", "37602", "39026", "74227", "65088", "81400", "03432", "86050", "86047", "95378", "95467"]
-    if payer_id not in valid_payer_ids:
-        raise ValueError("Invalid payer_id: {}. Must be one of: {}".format(payer_id, ", ".join(valid_payer_ids)))
-    
     # Prefer OPTUMAI endpoint if configured, otherwise fall back to legacy UHCAPI super connector
     try:
         endpoints_cfg = client.config['MediLink_Config']['endpoints']
@@ -889,6 +983,14 @@ def get_eligibility_super_connector(client, payer_id, provider_last_name, search
         except Exception:
             url_extension = None
 
+    # Validate payer_id against the selected endpoint's list
+    # - If OPTUMAI is used, allow the augmented list (includes LIFE1, WELM2, etc.).
+    # - If UHCAPI fallback is used, enforce strict UHC list only.
+    valid_payer_ids = get_valid_payer_ids_for_endpoint(client, endpoint_name)
+    if payer_id not in valid_payer_ids:
+        raise ValueError("Invalid payer_id: {} for endpoint {}. Must be one of: {}".format(
+            payer_id, endpoint_name, ", ".join(valid_payer_ids)))
+
     if not url_extension:
         raise ValueError("Eligibility endpoint not configured for {}".format(endpoint_name))
 

MediCafe/core_utils.py

@@ -499,9 +499,7 @@ def get_api_client_factory():
     """
     # Try multiple import paths for factory
     import_specs = [
-        ('MediCafe.api_factory', 'APIClientFactory'),
-        ('MediLink.MediLink_API_Factory', 'APIClientFactory'),  # Legacy fallback
-        ('MediLink_API_Factory', 'APIClientFactory')  # Legacy fallback
+        ('MediCafe.api_factory', 'APIClientFactory')
     ]
     
     APIClientFactory = import_with_alternatives(import_specs)
@@ -728,4 +726,11 @@ def check_ascii_files(paths):
     except Exception:
         # If a failure occurs mid-scan, return what we have so far
         return problematic
-    return problematic
+    return problematic
+
+def sanitize_log(message):
+    # Simple masking: replace DOB-like with ****-**-**, IDs with last4
+    import re
+    message = re.sub(r'\d{4}-\d{2}-\d{2}', '****-**-**', message)  # DOB
+    message = re.sub(r'\d{9,}', lambda m: '***' + m.group(0)[-4:], message)  # IDs
+    return message