medicafe 0.251023.1__tar.gz → 0.251023.2__tar.gz

{medicafe-0.251023.1 → medicafe-0.251023.2}/MediBot/__init__.py

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

{medicafe-0.251023.1 → medicafe-0.251023.2}/MediCafe/__init__.py

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

{medicafe-0.251023.1 → medicafe-0.251023.2}/MediCafe/api_core.py

@@ -1212,14 +1212,14 @@ def get_eligibility_super_connector(client, payer_id, provider_last_name, search
                                    corporate_tax_owner_id=None, corporate_tax_owner_name=None, organization_name=None, 
                                    organization_id=None, identify_service_level_deductible=True):
     """
-    GraphQL Super Connector version of eligibility check that maps to the same interface as get_eligibility_v3.
-    This function provides a drop-in replacement for the REST API with identical input/output behavior.
+    OPTUMAI eligibility (GraphQL) that maps to the same interface as get_eligibility_v3.
+    This function does not perform legacy fallback; callers should invoke legacy v3 separately if desired.
     """
     # Ensure all required parameters have values
     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")
 
-    # Prefer OPTUMAI endpoint if configured, otherwise fall back to legacy UHCAPI super connector
+    # Prefer OPTUMAI endpoint if configured, otherwise fall back to legacy UHCAPI v3 (REST)
     try:
         endpoints_cfg = client.config['MediLink_Config']['endpoints']
     except Exception:
@@ -1240,12 +1240,8 @@ def get_eligibility_super_connector(client, payer_id, provider_last_name, search
         pass
 
     if not endpoint_name:
-        # Fallback to legacy UHCAPI super connector path for backward compatibility
-        endpoint_name = 'UHCAPI'
-        try:
-            url_extension = endpoints_cfg.get(endpoint_name, {}).get('additional_endpoints', {}).get('eligibility_super_connector')
-        except Exception:
-            url_extension = None
+        # No fallback from this function; surface configuration error
+        raise ValueError("OPTUMAI eligibility endpoint not configured")
 
     # Validate payer_id against the selected endpoint's list
     # - If OPTUMAI is used, allow the augmented list (includes LIFE1, WELM2, etc.).
@@ -1258,17 +1254,17 @@ def get_eligibility_super_connector(client, payer_id, provider_last_name, search
     if not url_extension:
         raise ValueError("Eligibility endpoint not configured for {}".format(endpoint_name))
 
-    # Debug/trace: indicate which endpoint/path is being used for the Super Connector call
+    # Debug/trace: indicate that OPTUMAI eligibility path is active
     try:
         MediLink_ConfigLoader.log(
-            "Super Connector eligibility using endpoint '{}' with path '{}'".format(endpoint_name, url_extension),
+            "Eligibility using OPTUMAI endpoint with path '{}'".format(url_extension),
             level="INFO",
             console_output=CONSOLE_LOGGING
         )
     except Exception:
         pass
     try:
-        print("[Eligibility] Using endpoint: {} (path: {})".format(endpoint_name, url_extension))
+        print("[Eligibility] Using OPTUMAI (path: {})".format(url_extension))
     except Exception:
         pass
     
@@ -1405,36 +1401,8 @@ def get_eligibility_super_connector(client, payer_id, provider_last_name, search
         except Exception:
             pass
 
-        # Progressive hardening: allow disabling fallback to UHC via config
-        try:
-            disable_fallback = False
-            try:
-                disable_fallback = bool(medi.get('optumai_disable_fallback', False))
-            except Exception:
-                disable_fallback = False
-            if not disable_fallback and endpoint_name == 'OPTUMAI':
-                fallback_url = endpoints_cfg.get('UHCAPI', {}).get('additional_endpoints', {}).get('eligibility_super_connector')
-                if fallback_url:
-                    try:
-                        MediLink_ConfigLoader.log(
-                            "OPTUMAI call failed. Falling back to UHCAPI path '{}'".format(fallback_url),
-                            level="WARNING",
-                            console_output=CONSOLE_LOGGING
-                        )
-                    except Exception:
-                        pass
-                    try:
-                        print("[Eligibility] Fallback to UHCAPI (path: {})".format(fallback_url))
-                    except Exception:
-                        pass
-                    response = client.make_api_call('UHCAPI', 'POST', fallback_url, params=None, data=graphql_body, headers=headers)
-                else:
-                    raise
-            else:
-                raise
-        except Exception:
-            # Propagate original error if fallback not possible or also fails
-            raise
+        # No fallback from this function; re-raise so callers can handle or try legacy explicitly
+        raise
     
     # Transform GraphQL response to match REST API format
     # This ensures the calling code doesn't know the difference
@@ -1446,7 +1414,7 @@ def get_eligibility_super_connector(client, payer_id, provider_last_name, search
         if sc_status and sc_status != '200':
             msg = transformed_response.get('message')
             MediLink_ConfigLoader.log(
-                "Super Connector transformed response status: {} msg: {}".format(sc_status, msg),
+                "OPTUMAI eligibility transformed response status: {} msg: {}".format(sc_status, msg),
                 level="INFO",
                 console_output=CONSOLE_LOGGING
             )

{medicafe-0.251023.1 → medicafe-0.251023.2}/MediLink/MediLink_Deductible.py

@@ -549,6 +549,7 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
             # Enable verbose diagnostics in debug mode without config changes
             diagnostics_verbose = True
             sc_preflight_failed = False
+            # NOTE: No config flag mutation needed; OPTUMAI call now never auto-falls back
             
             # Get legacy response
             MediLink_ConfigLoader.log("Getting legacy get_eligibility_v3 API response", level="INFO")
@@ -569,8 +570,8 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
             else:
                 MediLink_ConfigLoader.log("API client does not support token authentication for Legacy API.", level="WARNING")
             
-            # Get Super Connector response for comparison
-            MediLink_ConfigLoader.log("Getting new get_eligibility_super_connector API response", level="INFO")
+            # Get OPTUMAI eligibility response for comparison (formerly Super Connector)
+            MediLink_ConfigLoader.log("Getting OPTUMAI eligibility API response", level="INFO")
             super_connector_eligibility = None
             try:
                 if not sc_preflight_failed:
@@ -580,32 +581,32 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
                 else:
                     super_connector_eligibility = None
             except Exception as e:
-                MediLink_ConfigLoader.log("Super Connector API failed: {}".format(e), level="ERROR")
+                MediLink_ConfigLoader.log("OPTUMAI eligibility API failed: {}".format(e), level="ERROR")
                 # Best-effort triage classification for clearer downstream messaging
                 try:
                     # Use centralized classifier when available
                     from MediCafe.deductible_utils import classify_api_failure
-                    code, message = classify_api_failure(e, 'Super Connector API')
+                    code, message = classify_api_failure(e, 'OPTUMAI eligibility API')
                     # Sticky preflight failure for subsequent patients in this run
                     if code in ['TIMEOUT', 'CONN_ERR', 'AUTH_FAIL', 'MISCONFIG']:
                         sc_preflight_failed = True
                 except Exception:
                     try:
-                        failure_reason = "Super Connector API connection failed"
+                        failure_reason = "OPTUMAI eligibility API connection failed"
                         detail = str(e)
                         if requests and hasattr(requests, 'exceptions') and isinstance(e, requests.exceptions.Timeout):
-                            failure_reason = "Super Connector API timeout"
+                            failure_reason = "OPTUMAI eligibility API timeout"
                         elif requests and hasattr(requests, 'exceptions') and isinstance(e, requests.exceptions.ConnectionError):
-                            failure_reason = "Super Connector API connection error"
+                            failure_reason = "OPTUMAI eligibility API connection error"
                         elif "Invalid payer_id" in detail:
-                            failure_reason = "Super Connector API rejected payer_id"
+                            failure_reason = "OPTUMAI eligibility API rejected payer_id"
                         elif ("No access token" in detail) or ("token" in detail.lower()):
-                            failure_reason = "Super Connector API authentication failed"
+                            failure_reason = "OPTUMAI eligibility API authentication failed"
                         elif ("Eligibility endpoint not configured" in detail) or ("endpoint" in detail.lower() and "configured" in detail.lower()):
-                            failure_reason = "Super Connector API endpoint misconfigured"
+                            failure_reason = "OPTUMAI eligibility API endpoint misconfigured"
                         message = "{}: {}".format(failure_reason, detail)
                     except Exception:
-                        message = "Super Connector API failed: {}".format(str(e))
+                        message = "OPTUMAI eligibility API failed: {}".format(str(e))
                 sc_failure_info = {"message": message}
                 try:
                     error_messages_for_row.append(message)
@@ -629,22 +630,22 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
                     )
                     print("\nValidation report generated (legacy only): {}".format(validation_file_path))
                 elif super_connector_eligibility:
-                    # Only Super Connector API returned data
+                    # Only OPTUMAI eligibility API returned data
                     validation_report = MediLink_Deductible_Validator.run_validation_comparison(
                         None, super_connector_eligibility, validation_file_path
                     )
-                    print("\nValidation report generated (Super Connector only): {}".format(validation_file_path))
+                    print("\nValidation report generated (OPTUMAI only): {}".format(validation_file_path))
                 else:
                     # Neither API returned data
                     print("\nNo validation report generated - both APIs failed")
                     validation_file_path = None
                 
-                # Log any Super Connector API errors if we have that data
+                # Log any OPTUMAI eligibility API errors if we have that data
                 if super_connector_eligibility and "rawGraphQLResponse" in super_connector_eligibility:
                     raw_response = super_connector_eligibility.get('rawGraphQLResponse', {})
                     errors = raw_response.get('errors', [])
                     if errors:
-                        error_msg = "Super Connector API returned {} error(s):".format(len(errors))
+                        error_msg = "OPTUMAI eligibility API returned {} error(s):".format(len(errors))
                         if error_msg not in printed_messages:
                             print(error_msg)
                             printed_messages.add(error_msg)
@@ -703,15 +704,15 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
                     status_code = super_connector_eligibility.get('statuscode')
                     from MediCafe.deductible_utils import is_ok_200
                     if status_code is not None and not is_ok_200(status_code):
-                        print("Super Connector API status code: {} (non-200 indicates errors)".format(status_code))
+                        print("OPTUMAI eligibility API status code: {} (non-200 indicates errors)".format(status_code))
                         # Record status code for the row diagnostics
-                        error_messages_for_row.append("Status code {} from Super Connector".format(status_code))
+                        error_messages_for_row.append("Status code {} from OPTUMAI eligibility".format(status_code))
                 # If Super Connector failed entirely, append a triage note to the validation report (if created)
                 try:
                     if sc_failure_info and validation_file_path and os.path.exists(validation_file_path):
                         with open(validation_file_path, 'a') as vf:
                             vf.write("\n" + "-" * 80 + "\n")
-                            vf.write("SUPER CONNECTOR CONNECTION FAILURE NOTE\n")
+                            vf.write("OPTUMAI ELIGIBILITY CONNECTION FAILURE NOTE\n")
                             vf.write("-" * 80 + "\n")
                             vf.write(sc_failure_info['message'] + "\n")
                             vf.write("Recommendation: Verify network connectivity, credentials, payer ID validity, and endpoint configuration.\n")
@@ -741,7 +742,7 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
                         merged_data['error_messages'] = error_messages_for_row
                 except Exception:
                     pass
-                # Surface Super Connector failure prominently in user-facing diagnostics
+                # Surface OPTUMAI eligibility failure prominently in user-facing diagnostics
                 try:
                     if sc_failure_info and isinstance(merged_data, dict):
                         merged_data['super_connector_failed'] = True
@@ -943,7 +944,7 @@ if __name__ == "__main__":
         print("- Crosswalk-based payer ID resolution (O(N) complexity)")
     elif DEBUG_MODE:
         print("\nRunning in DEBUG MODE")
-        print("- Dual API calls (Legacy + Super Connector)")
+        print("- Dual API calls (Legacy + OPTUMAI eligibility)")
         print("- Validation reports and comparisons")
         print("- Detailed logging and error reporting")
         print("- Crosswalk-based payer ID resolution (O(N) complexity)")
@@ -1193,11 +1194,11 @@ if __name__ == "__main__":
                 output_file.write(table_header + "\n")
                 output_file.write("-" * len(table_header) + "\n")
 
-                # Global notice when Super Connector connection failed for any patients
+                # Global notice when OPTUMAI eligibility connection failed for any patients
                 try:
                     sc_failed_count = sum(1 for r in eligibility_results if isinstance(r, dict) and r.get('super_connector_failed'))
                     if sc_failed_count:
-                        output_file.write("NOTICE: Super Connector API connection failed for {} patient(s). Fallback data used when available.\n".format(sc_failed_count))
+                        output_file.write("NOTICE: OPTUMAI eligibility API connection failed for {} patient(s). Fallback data used when available.\n".format(sc_failed_count))
                 except Exception:
                     pass
                 
@@ -1260,7 +1261,7 @@ if __name__ == "__main__":
                 else:
                     print("No validation reports were generated.")
                     print("This may be because:")
-                    print("  - Super Connector API calls failed")
+                    print("  - OPTUMAI eligibility API calls failed")
                     print("  - Both APIs didn't return data for the same patients")
                     print("  - Validation report generation encountered errors")
                 print("=" * 80)

{medicafe-0.251023.1 → medicafe-0.251023.2}/MediLink/__init__.py

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

{medicafe-0.251023.1/medicafe.egg-info → medicafe-0.251023.2}/PKG-INFO

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

{medicafe-0.251023.1 → medicafe-0.251023.2/medicafe.egg-info}/PKG-INFO

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

{medicafe-0.251023.1 → medicafe-0.251023.2}/setup.py

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