Upload validation_engine.py

llm/validation_engine.py

@@ -0,0 +1,132 @@
+"""
+Flare – Parameter Validation (locale-aware)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Locale-based validation with multi-language support
+"""
+
+import re
+from typing import Any, Optional, List
+from datetime import datetime
+from config_models import ParameterConfig
+from locale_manager import LocaleManager
+from logger import log_info, log_error, log_warning, log_debug
+
+def validate(value: str, param: ParameterConfig, locale: Optional[str] = None) -> bool:
+    """Validate parameter value based on type and locale"""
+    t = param.canonical_type()
+    
+    if t == "int":
+        if not value.isdigit(): 
+            return False
+    elif t == "float":
+        try: 
+            float(value)
+        except ValueError: 
+            return False
+    elif t in ("str", "string"):
+        pass  # All strings are valid
+    elif t == "bool":
+        # Locale-aware boolean validation
+        return validate_boolean(value, locale)
+    elif t == "date":
+        try:
+            # Check if it's a valid ISO date format (YYYY-MM-DD)
+            datetime.strptime(value, "%Y-%m-%d")
+        except ValueError:
+            return False
+
+    # Regex validation if provided
+    if param.validation_regex and not re.fullmatch(param.validation_regex, value, re.I):
+        return False
+        
+    return True
+
+def validate_boolean(value: str, locale: Optional[str] = None) -> bool:
+    """Validate boolean value based on locale"""
+    # Default values (always accepted)
+    default_true = ["1", "true"]
+    default_false = ["0", "false"]
+    
+    value_lower = value.lower().strip()
+    
+    # Check default values first
+    if value_lower in default_true or value_lower in default_false:
+        return True
+    
+    # If no locale specified, use minimal validation
+    if not locale:
+        return value_lower in ["yes", "no", "evet", "hayır"]
+    
+    try:
+        # Get locale data
+        locale_data = LocaleManager.get_locale(locale)
+        
+        # Get boolean values from locale
+        boolean_values = locale_data.get("boolean_values", {})
+        true_values = boolean_values.get("true_values", [])
+        false_values = boolean_values.get("false_values", [])
+        
+        # Include synonyms if available
+        yes_synonyms = boolean_values.get("yes_synonyms", [])
+        no_synonyms = boolean_values.get("no_synonyms", [])
+        
+        # Combine all accepted values
+        all_true_values = set(true_values + yes_synonyms + default_true)
+        all_false_values = set(false_values + no_synonyms + default_false)
+        
+        # Convert to lowercase for comparison
+        all_true_values = {v.lower() for v in all_true_values}
+        all_false_values = {v.lower() for v in all_false_values}
+        
+        return value_lower in all_true_values or value_lower in all_false_values
+        
+    except Exception as e:
+        log_error("⚠️ Error in locale-based boolean validation", e)
+        # Fallback to basic validation
+        return value_lower in ["yes", "no", "evet", "hayır", "1", "0", "true", "false"]
+
+def get_boolean_value(value: str, locale: Optional[str] = None) -> Optional[bool]:
+    """Convert locale-specific boolean string to Python bool"""
+    value_lower = value.lower().strip()
+    
+    # Default true values
+    if value_lower in ["1", "true"]:
+        return True
+    if value_lower in ["0", "false"]:
+        return False
+    
+    if not locale:
+        # Basic conversion without locale
+        if value_lower in ["yes", "evet"]:
+            return True
+        elif value_lower in ["no", "hayır"]:
+            return False
+        return None
+    
+    try:
+        # Get locale data
+        locale_data = LocaleManager.get_locale(locale)
+        boolean_values = locale_data.get("boolean_values", {})
+        
+        true_values = set(v.lower() for v in boolean_values.get("true_values", []))
+        false_values = set(v.lower() for v in boolean_values.get("false_values", []))
+        yes_synonyms = set(v.lower() for v in boolean_values.get("yes_synonyms", []))
+        no_synonyms = set(v.lower() for v in boolean_values.get("no_synonyms", []))
+        
+        # Check if it's a true value
+        if value_lower in true_values or value_lower in yes_synonyms or value_lower == "1":
+            return True
+        
+        # Check if it's a false value
+        if value_lower in false_values or value_lower in no_synonyms or value_lower == "0":
+            return False
+        
+        return None
+        
+    except Exception as e:
+        log_error("⚠️ Error converting boolean value", e)
+        return None
+
+def get_supported_locales() -> List[str]:
+    """Get list of supported locales for validation"""
+    return LocaleManager.list_available_locales()