{
  "response_data": {
    "number": 129.99,
    "formatted_value": "$129.99 USD"
  }
}

def validate_number_response(response_data, response_config):
    """Validate number response against configuration"""
    
    if not isinstance(response_data, dict):
        return False, "Response must be an object"
    
    if "number" not in response_data:
        return False, "Missing number field"
    
    number = response_data["number"]
    
    # Validate numeric type
    if not isinstance(number, (int, float)):
        return False, "Value must be a number"
    
    # Check range bounds
    min_value = response_config.get("min_value", 0)
    max_value = response_config["max_value"]
    
    if number < min_value:
        return False, f"Value must be at least {min_value}"
    
    if number > max_value:
        return False, f"Value cannot exceed {max_value}"
    
    # Check negative values
    allow_negative = response_config.get("allow_negative", False)
    if not allow_negative and number < 0:
        return False, "Negative values are not allowed"
    
    # Check decimal places
    decimal_places = response_config.get("decimal_places", 2)
    if decimal_places == 0 and number != int(number):
        return False, "Decimal values are not allowed"
    
    # Validate decimal precision
    decimal_str = str(number).split('.')[1] if '.' in str(number) else ""
    if len(decimal_str) > decimal_places:
        return False, f"Maximum {decimal_places} decimal places allowed"
    
    # Check required
    if response_config.get("required", False) and number is None:
        return False, "Number is required"
    
    return True, "Valid"

# Usage example
is_valid, error_message = validate_number_response(
    response_data={
        "number": 149.99,
        "formatted_value": "$149.99 USD"
    },
    response_config={
        "min_value": 50.00,
        "max_value": 500.00,
        "decimal_places": 2,
        "allow_negative": False,
        "required": True
    }
)

# Adjust validation ranges based on context
def get_dynamic_price_range(product_category, market_tier):
    """Calculate appropriate price ranges based on product context"""
    
    base_ranges = {
        "electronics": {"budget": (20, 200), "premium": (200, 2000)},
        "clothing": {"budget": (10, 100), "premium": (100, 500)},
        "home": {"budget": (25, 250), "premium": (250, 1000)}
    }
    
    if product_category in base_ranges:
        min_val, max_val = base_ranges[product_category][market_tier]
        return {
            "min_value": min_val,
            "max_value": max_val,
            "decimal_places": 2,
            "prefix": "$",
            "suffix": " USD"
        }
    
    # Default fallback
    return {
        "min_value": 1.00,
        "max_value": 1000.00,
        "decimal_places": 2,
        "prefix": "$",
        "suffix": " USD"
    }

# Handle different currencies based on user location
def get_currency_config(user_location):
    """Generate number config for appropriate currency"""
    
    currency_configs = {
        "US": {"prefix": "$", "suffix": " USD", "decimal_places": 2},
        "EU": {"prefix": "€", "suffix": " EUR", "decimal_places": 2},
        "UK": {"prefix": "£", "suffix": " GBP", "decimal_places": 2},
        "JP": {"prefix": "¥", "suffix": " JPY", "decimal_places": 0}
    }
    
    return currency_configs.get(user_location, currency_configs["US"])

# Process multiple number responses together
def calculate_weighted_average(number_responses, weights=None):
    """Calculate weighted average from multiple number responses"""
    
    if not number_responses:
        return None
    
    numbers = [response["number"] for response in number_responses]
    
    if weights and len(weights) == len(numbers):
        weighted_sum = sum(n * w for n, w in zip(numbers, weights))
        total_weight = sum(weights)
        return weighted_sum / total_weight if total_weight > 0 else None
    else:
        # Simple average if no weights provided
        return sum(numbers) / len(numbers)