Update sozo_gen.py

sozo_gen.py

@@ -258,31 +258,17 @@ def concat_media(file_paths: List[str], output_path: Path):
     finally:
         list_file.unlink(missing_ok=True)
 
-# Safe, backward-compatible fix that only patches the specific problematic calls
+# DROP-IN FIX - requires zero code changes
 import json as _original_json
-import builtins
-
-# Store original functions
-_original_str = builtins.str
-_original_dumps = _original_json.dumps
-
-def safe_str(obj):
-    """Safe str() that handles Firebase compatibility."""
-    try:
-        result = _original_str(obj)
-        # Clean for Firebase - remove problematic characters
-        clean_result = ''.join(char for char in result if ord(char) >= 32 or char in '\n\r\t')
-        # Limit length
-        if len(clean_result) > 1000:
-            clean_result = clean_result[:1000] + "... (truncated)"
-        return clean_result
-    except Exception:
-        return "Error occurred during processing"
 
 def safe_json_dumps(obj, **kwargs):
     """Safe JSON dumps that handles non-serializable types."""
     def make_serializable(item):
-        if isinstance(item, (str, int, float, type(None), bool)):
+        if item is None:
+            return None
+        elif isinstance(item, bool):  # Check bool before int since bool is subclass of int
+            return item
+        elif isinstance(item, (int, float, str)):
             return item
         elif isinstance(item, (list, tuple)):
             return [make_serializable(x) for x in item]
@@ -292,42 +278,42 @@ def safe_json_dumps(obj, **kwargs):
             return str(item)
     
     try:
-        return _original_dumps(make_serializable(obj), **kwargs)
-    except Exception as e:
-        logging.warning(f"JSON serialization failed: {e}")
-        return _original_str(obj)
-
-# Only apply patches in specific contexts to avoid breaking Firebase
-import sys
-import traceback
-
-def contextual_json_dumps(obj, **kwargs):
-    """Only apply safe JSON dumps when called from problematic contexts."""
-    # Check if we're in the ChartGenerator context
-    frame = sys._getframe(1)
-    if frame and hasattr(frame, 'f_code'):
-        # Check if this is called from generate_chart_spec or similar
-        if 'generate_chart_spec' in frame.f_code.co_name or 'ChartGenerator' in str(frame.f_locals):
-            return safe_json_dumps(obj, **kwargs)
-    
-    # Use original for everything else (including Firebase)
-    return _original_dumps(obj, **kwargs)
-
-def contextual_str(obj):
-    """Only apply safe str when called from Firebase error contexts."""
-    # Check if we're in an error handling context
-    frame = sys._getframe(1)
-    if frame and hasattr(frame, 'f_code'):
-        # Check if this is called from Firebase update error handling
-        if 'update' in frame.f_code.co_name and any('firebase' in str(v).lower() for v in frame.f_locals.values() if v):
-            return safe_str(obj)
-    
-    # Use original for everything else
-    return _original_str(obj)
-
-# Apply contextual patches
-_original_json.dumps = contextual_json_dumps
-builtins.str = contextual_str
+        serializable_obj = make_serializable(obj)
+        return _original_json.dumps(serializable_obj, **kwargs)
+    except Exception:
+        return f'"{str(obj)}"'
+
+# Patch json.dumps
+_original_json.dumps = safe_json_dumps
+
+# Patch Firebase Reference.update to handle error strings safely
+try:
+    from firebase_admin import db
+    _original_update = db.Reference.update
+    
+    def safe_update(self, value):
+        """Safe wrapper for Firebase update that cleans error strings."""
+        if isinstance(value, dict) and 'error' in value:
+            try:
+                # Clean the error string for Firebase
+                error_str = str(value['error'])
+                clean_error = ''.join(char for char in error_str if 32 <= ord(char) <= 126 or char in '\n\r\t ')
+                if len(clean_error) > 1000:
+                    clean_error = clean_error[:1000] + "... (truncated)"
+                value = dict(value)  # Create a copy
+                value['error'] = clean_error
+            except Exception:
+                # If cleaning fails, use a generic error message
+                value = dict(value)  # Create a copy
+                value['error'] = 'An error occurred during processing'
+        
+        return _original_update(self, value)
+    
+    db.Reference.update = safe_update
+    
+except ImportError:
+    # firebase_admin not available, skip patching
+    pass
 
 # --- Main Business Logic Functions for Flask ---