Troubleshooting

import lume

# Verify SDK installation and configuration
print(f"SDK Version: {lume.__version__}")
print(f"API URL: {lume.get_api_url()}")

# Test authentication
try:
    # Basic authentication test
    print("✅ Authentication successful")
except Exception as e:
    print(f"❌ Authentication failed: {e}")

# Get detailed run information
run = lume.get_run("run_01HX...")
print(f"Status: {run.status}")
print(f"Error Rate: {run.metrics.error_rate:.2%}")
print(f"Runtime: {run.metrics.runtime_seconds:.2f} seconds")

import os
print(f"Token set: {'LUME_TOKEN' in os.environ}")
print(f"Token length: {len(os.getenv('LUME_TOKEN', ''))}")

# Check exact flow version name
flow_version = "invoice_cleaner:v4"  # Must match exactly
print(f"Using flow version: {flow_version}")

# Check file accessibility
input_files = [
    "s3://bucket/file.csv"           # S3
]

# Test file access (basic check)
import requests
for file_url in input_files:
    if file_url.startswith("https://"):
        try:
            response = requests.head(file_url)
            print(f"{file_url}: {response.status_code}")
        except Exception as e:
            print(f"{file_url}: Error - {e}")

# Ensure files are CSV format
def validate_csv_files(file_urls):
    for url in file_urls:
        if not url.lower().endswith('.csv'):
            raise ValueError(f"Non-CSV file detected: {url}")
        print(f"✅ CSV file: {url}")

validate_csv_files(input_files)

import pandas as pd

def validate_csv_format(file_url):
    """Validate that file is actually CSV format"""
    try:
        # Try to read as CSV
        df = pd.read_csv(file_url, nrows=5)
        print(f"✅ Valid CSV: {file_url} ({len(df.columns)} columns)")
        return True
    except Exception as e:
        print(f"❌ Invalid CSV: {file_url} - {e}")
        return False

# Validate all input files
for file_url in input_files:
    validate_csv_format(file_url)

# Convert Excel files to CSV (if needed)
import pandas as pd

def convert_excel_to_csv(excel_url, csv_url):
    """Convert Excel file to CSV format"""
    df = pd.read_excel(excel_url)
    df.to_csv(csv_url, index=False)
    print(f"Converted {excel_url} to {csv_url}")

# Validate seed file accessibility
seed_files = ["s3://reference/customer_lookup.csv"]

for seed_file in seed_files:
    if not seed_file.lower().endswith('.csv'):
        raise ValueError(f"Seed file must be CSV: {seed_file}")
    print(f"✅ Seed file: {seed_file}")

# Test seed file access before running transformation
def test_seed_files(seed_files):
    for seed_file in seed_files:
        try:
            # Try to read first few rows
            df = pd.read_csv(seed_file, nrows=5)
            print(f"✅ Seed file accessible: {seed_file} ({len(df)} rows)")
        except Exception as e:
            print(f"❌ Seed file error: {seed_file} - {e}")
            raise

test_seed_files(seed_files)

# Download and analyze rejected rows
run.download_rejects("./rejects", output_format="csv")

# Read rejects file
rejects_df = pd.read_csv("./rejects/part-0000.csv")
print(f"Rejected rows: {len(rejects_df)}")

# Analyze error patterns
error_counts = rejects_df['error_code'].value_counts()
print("Top error types:")
for error, count in error_counts.head().items():
    print(f"  {error}: {count}")

# Analyze input data quality
def analyze_input_quality(file_url):
    df = pd.read_csv(file_url)
    
    print(f"File: {file_url}")
    print(f"Rows: {len(df)}")
    print(f"Columns: {len(df.columns)}")
    print(f"Missing values: {df.isnull().sum().sum()}")
    print(f"Duplicate rows: {df.duplicated().sum()}")
    
    # Check for common issues
    for col in df.columns:
        if df[col].dtype == 'object':
            # Check for mixed data types
            unique_types = df[col].apply(type).unique()
            if len(unique_types) > 1:
                print(f"  Mixed types in {col}: {unique_types}")

analyze_input_quality("s3://bucket/invoices.csv")

def analyze_run(run_id):
    """Comprehensive analysis of a run"""
    run = lume.get_run(run_id)
    
    print(f"=== Run Analysis: {run_id} ===")
    print(f"Status: {run.status}")
    print(f"Flow Version: {run.flow_version}")
    print(f"Created: {run.created_at}")
    
    print(f"\n=== Metrics ===")
    print(f"Error Rate: {run.metrics.error_rate:.2%}")
    print(f"Runtime: {run.metrics.runtime_seconds:.2f} seconds")
    
    print(f"\n=== Row Counts ===")
    print(f"Input: {run.metrics.row_counts['input']}")
    print(f"Mapped: {run.metrics.row_counts['mapped']}")
    print(f"Rejects: {run.metrics.row_counts['rejects']}")
    
    print(f"\n=== Validation Summary ===")
    validation = run.metrics.validation_summary
    print(f"Tests Executed: {validation['tests_executed']}")
    print(f"Tests Failed: {validation['tests_failed']}")
    
    if validation['top_errors']:
        print("Top Errors:")
        for error in validation['top_errors']:
            print(f"  {error['error_code']}: {error['count']}")
    
    return run

# Usage
run = analyze_run("run_01HX...")

def health_check():
    """Comprehensive health check"""
    print("=== Health Check ===")
    
    # Check authentication
    try:
        # Basic authentication test
        print("✅ Authentication: OK")
    except Exception as e:
        print(f"❌ Authentication: FAILED - {e}")
        return False
    
    # Check configuration
    print(f"✅ API URL: {lume.get_api_url()}")
    
    return True

# Run health check
health_check()