Update main.py

main.py

@@ -387,9 +387,7 @@ def generate_visualization_code(df: pd.DataFrame, request: VisualizationRequest)
     ])
     
     return "\n".join(code_lines)
-def interpret_natural_language(prompt: str, df_columns: list) -> VisualizationRequest:
-    """Convert natural language prompt to visualization parameters"""
-    prompt = prompt.lower()
+
     
     # Determine chart type
     chart_type = "bar"
@@ -432,65 +430,47 @@ def interpret_natural_language(prompt: str, df_columns: list) -> VisualizationRe
         title="Generated from: " + prompt[:50] + ("..." if len(prompt) > 50 else ""),
         style="seaborn-v0_8"  # Updated default
     )
-def interpret_natural_language(prompt: str, df_columns: list) -> VisualizationRequest:
+from typing import Optional
+
+def interpret_natural_language(prompt: str, df_columns: list) -> Optional[VisualizationRequest]:
     """Convert natural language prompt to visualization parameters"""
+    if not prompt or not df_columns:
+        return None
+        
     prompt = prompt.lower()
+    # [rest of your existing function...]
 
 # ===== DYNAMIC VISUALIZATION FUNCTIONS =====
 def read_any_excel(content: bytes) -> pd.DataFrame:
     """Read any Excel file with automatic type detection"""
     try:
-        # First pass to detect datetime columns
-        df = pd.read_excel(
-            io.BytesIO(content),
-            engine='openpyxl',
-            nrows=10  # Only read first few rows for detection
-        )
-        
-        # Identify likely datetime columns
-        date_cols = [
-            col for col in df.columns 
-            if df[col].dtype == 'object' and 
-            any(is_date_like(str(x)) for x in df[col].head() if pd.notna(x))
-        ]
-        
-        # Full read with proper typing
+        # First read without parsing dates to detect datetime columns
         df = pd.read_excel(
             io.BytesIO(content),
             engine='openpyxl',
-            parse_dates=date_cols,
-            date_parser=lambda x: pd.to_datetime(x, errors='coerce'),
             dtype=object,  # Read everything as object initially
             na_values=['', '#N/A', '#VALUE!', '#REF!', 'NULL', 'NA', 'N/A']
         )
         
         # Convert each column to best possible type
         for col in df.columns:
-            # Skip if already datetime
-            if pd.api.types.is_datetime64_any_dtype(df[col]):
+            # First try numeric conversion
+            try:
+                df[col] = pd.to_numeric(df[col])
                 continue
+            except (ValueError, TypeError):
+                pass
                 
-            # Try numeric first
+            # Then try datetime with explicit format
             try:
-                df[col] = pd.to_numeric(df[col], errors='ignore')
-                if df[col].dtype.kind in 'biufc':  # Is numeric type
-                    continue
-            except:
+                df[col] = pd.to_datetime(df[col], format='mixed')
+                continue
+            except (ValueError, TypeError):
                 pass
                 
-            # Then try datetime again (in case missed earlier)
-            if df[col].dtype == 'object':
-                try:
-                    df[col] = pd.to_datetime(df[col], errors='ignore')
-                    if pd.api.types.is_datetime64_any_dtype(df[col]):
-                        continue
-                except:
-                    pass
-                
             # Finally clean strings
-            if df[col].dtype == 'object':
-                df[col] = df[col].astype(str).str.strip()
-                df[col] = df[col].replace(['nan', 'None', 'NaT', ''], None)
+            df[col] = df[col].astype(str).str.strip()
+            df[col] = df[col].replace(['nan', 'None', 'NaT', ''], None)
         
         return df
     
@@ -498,6 +478,13 @@ def read_any_excel(content: bytes) -> pd.DataFrame:
         logger.error(f"Excel reading failed: {str(e)}")
         raise HTTPException(422, f"Could not process Excel file: {str(e)}")
 
+
+        
+    
+    except Exception as e:
+        logger.error(f"Excel reading failed: {str(e)}")
+        raise HTTPException(422, f"Could not process Excel file: {str(e)}")
+
 def is_date_like(s: str) -> bool:
     """Helper to detect date-like strings"""
     date_patterns = [
@@ -804,14 +791,16 @@ async def visualize_with_natural_language(
         if not prompt.strip():
             prompt = generate_smart_prompt(df)
         
-        # Generate visualization
-        vis_request = interpret_natural_language(prompt, df.columns)
+        # Generate visualization request
+        vis_request = interpret_natural_language(prompt, df.columns.tolist())
+        if not vis_request:
+            raise HTTPException(400, "Could not interpret visualization request from prompt")
+            
         vis_request.style = style
         
-        # Generate and return visualization
+        # Generate the visualization code
         visualization_code = generate_dynamic_visualization_code(df, vis_request)
         
-        # [Rest of your existing visualization execution code...]
         # Create the plot in memory
         plt.style.use(vis_request.style)
         fig, ax = plt.subplots(figsize=(10, 6))
@@ -836,6 +825,18 @@ async def visualize_with_natural_language(
             "interpreted_parameters": vis_request.dict()
         }
 
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Natural language visualization failed: {str(e)}\n{traceback.format_exc()}")
+        raise HTTPException(500, detail=f"Visualization failed: {str(e)}")
+        return {
+            "status": "success",
+            "image_data": image_base64,
+            "code": visualization_code,
+            "interpreted_parameters": vis_request.dict()
+        }
+
     except HTTPException:
         raise
     except Exception as e: