Update sozo_gen.py

sozo_gen.py

@@ -258,99 +258,76 @@ def concat_media(file_paths: List[str], output_path: Path):
     finally:
         list_file.unlink(missing_ok=True)
 
-# Backward-compatible fix: Override json.dumps to handle non-serializable types
-import json as _json
+# Safe, backward-compatible fix that only patches the specific problematic calls
+import json as _original_json
+import builtins
 
-def safe_json_dumps(obj, indent=2, **kwargs):
-    """Safely serialize object to JSON, handling non-serializable types."""
-    def json_serializer(obj):
-        if isinstance(obj, (bool, int, float, str, type(None))):
-            return obj
-        elif isinstance(obj, (list, tuple)):
-            return [json_serializer(item) for item in obj]
-        elif isinstance(obj, dict):
-            return {key: json_serializer(value) for key, value in obj.items()}
-        else:
-            # Convert non-serializable objects to string representation
-            return str(obj)
-    
-    try:
-        return _json.dumps(json_serializer(obj), indent=indent, **kwargs)
-    except Exception as e:
-        logging.warning(f"JSON serialization failed: {e}")
-        return str(obj)
-
-# Monkey patch json.dumps to use our safe version
-json.dumps = safe_json_dumps
-
-def safe_firebase_data(obj):
-    """
-    Safely prepare data for Firebase by ensuring all values are JSON-serializable
-    and Firebase-compatible.
-    """
-    def clean_for_firebase(obj):
-        if obj is None:
-            return None
-        elif isinstance(obj, bool):
-            return obj
-        elif isinstance(obj, (int, float)):
-            return obj
-        elif isinstance(obj, str):
-            # Clean string for Firebase - remove null bytes and control characters
-            return ''.join(char for char in obj if ord(char) >= 32 or char in '\n\r\t')
-        elif isinstance(obj, (list, tuple)):
-            return [clean_for_firebase(item) for item in obj]
-        elif isinstance(obj, dict):
-            cleaned = {}
-            for key, value in obj.items():
-                # Firebase keys must be strings and can't contain certain characters
-                clean_key = str(key).replace('.', '_').replace('$', '_').replace('#', '_').replace('[', '_').replace(']', '_').replace('/', '_')
-                cleaned[clean_key] = clean_for_firebase(value)
-            return cleaned
-        else:
-            # Convert to string and clean
-            str_repr = str(obj)
-            return ''.join(char for char in str_repr if ord(char) >= 32 or char in '\n\r\t')
-    
-    return clean_for_firebase(obj)
+# Store original functions
+_original_str = builtins.str
+_original_dumps = _original_json.dumps
 
-def concat_media(file_paths: List[str], output_path: Path):
-    valid_paths = [p for p in file_paths if Path(p).exists() and Path(p).stat().st_size > 100]
-    if not valid_paths: raise ValueError("No valid media files to concatenate.")
-    if len(valid_paths) == 1: import shutil; shutil.copy2(valid_paths[0], str(output_path)); return
-    list_file = output_path.with_suffix(".txt")
-    with open(list_file, 'w') as f:
-        for path in valid_paths: f.write(f"file '{Path(path).resolve()}'\n")
-    cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", str(list_file), "-c", "copy", str(output_path)]
+def safe_str(obj):
+    """Safe str() that handles Firebase compatibility."""
     try:
-        subprocess.run(cmd, check=True, capture_output=True, text=True)
-    finally:
-        list_file.unlink(missing_ok=True)
-
-# Backward-compatible fix: Override json.dumps to handle non-serializable types
-import json as _json
-
-def safe_json_dumps(obj, indent=2, **kwargs):
-    """Safely serialize object to JSON, handling non-serializable types."""
-    def json_serializer(obj):
-        if isinstance(obj, (bool, int, float, str, type(None))):
-            return obj
-        elif isinstance(obj, (list, tuple)):
-            return [json_serializer(item) for item in obj]
-        elif isinstance(obj, dict):
-            return {key: json_serializer(value) for key, value in obj.items()}
+        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)):
+            return item
+        elif isinstance(item, (list, tuple)):
+            return [make_serializable(x) for x in item]
+        elif isinstance(item, dict):
+            return {str(k): make_serializable(v) for k, v in item.items()}
         else:
-            # Convert non-serializable objects to string representation
-            return str(obj)
+            return str(item)
     
     try:
-        return _json.dumps(json_serializer(obj), indent=indent, **kwargs)
+        return _original_dumps(make_serializable(obj), **kwargs)
     except Exception as e:
         logging.warning(f"JSON serialization failed: {e}")
-        return str(obj)
-
-# Monkey patch json.dumps to use our safe version
-json.dumps = safe_json_dumps
+        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
 
 # --- Main Business Logic Functions for Flask ---