Update database.py

database.py

@@ -1,102 +1,96 @@
-from sqlalchemy import (
-    create_engine,
-    MetaData,
-    Table,
-    Column,
-    String,
-    Integer,
-    Float,
-    insert,
-    text,
-)
-
-# Use a persistent SQLite database file
-engine = create_engine("sqlite:///database.db")
-metadata_obj = MetaData()
-
-def create_dynamic_table(df):
-    """
-    Creates a table dynamically based on DataFrame schema.
-
-    Args:
-        df: pandas DataFrame containing the data
+import json
+import gradio as gr
+from smolagents import CodeAgent, HfApiModel
+import pandas as pd
+from io import StringIO
 
-    Returns:
-        SQLAlchemy Table object
-    """
-    # Drop existing table if it exists
-    if 'data_table' in metadata_obj.tables:
-        metadata_obj.remove(metadata_obj.tables['data_table'])
-
-    # Define columns with a new auto-incrementing primary key
-    columns = [Column("uuid", Integer, primary_key=True, autoincrement=True)]  # New primary key
+agent = CodeAgent(
+    tools=[],
+    model=HfApiModel(model_id="Qwen/Qwen2.5-Coder-32B-Instruct"),
+    additional_authorized_imports=['json']
+)
 
-    # Add columns based on DataFrame dtypes
-    for col_name, dtype in df.dtypes.items():
-        if 'int' in str(dtype):
-            col_type = Integer
-        elif 'float' in str(dtype):
-            col_type = Float
+def parse_text_content(content):
+    """Universal text parser with multiple pattern handling"""
+    lines = content.split('\n')
+    csv_lines = ["id,description"]
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+            
+        # Handle ID-description pattern
+        if ' ' in line and len(line.split()) > 1:
+            parts = line.split(' ', 1)
+            clean_desc = parts[1].replace('(edited)', '').strip()
+            csv_lines.append(f"{parts[0]},{clean_desc}")
+            
+        # Handle separator pattern
+        elif '!' in line:
+            csv_lines.append(line.replace('!', ',', 1))
+            
+        # Handle single-value lines
         else:
-            col_type = String(255)  # Using a generous length for string columns
-
-        columns.append(Column(col_name, col_type))
-
-    # Create new table
-    table = Table('data_table', metadata_obj, *columns)
-
-    # Create table in database
-    metadata_obj.create_all(engine, tables=[table])
-
-    return table
-
-def clear_database():
-    """
-    Removes all tables from the database.
-    """
-    metadata_obj.drop_all(engine)
-    metadata_obj.clear()
-
-def insert_rows_into_table(rows, table):
-    """
-    Inserts rows into the specified table.
+            csv_lines.append(f"{line},")
     
-    Args:
-        rows: List of dictionaries containing the row data
-        table: SQLAlchemy Table object
-    """
-    with engine.begin() as connection:
-        connection.execute(insert(table), rows)
+    return '\n'.join(csv_lines)
 
-def get_table_schema():
-    """
-    Returns the current table schema as a string.
-    """
+def process_file(file_path):
+    """Process individual files with error handling"""
     try:
-        # Get list of tables
-        with engine.connect() as con:
-            tables = con.execute(text(
-                "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
-            )).fetchall()
-            
-        if not tables:
-            return None
-            
-        # Use the first table found
-        table_name = tables[0][0]
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
         
-        # Get column information
-        with engine.connect() as con:
-            columns = con.execute(text(f"PRAGMA table_info({table_name})")).fetchall()
-            
-        schema = []
-        for col in columns:
-            col_name = col[1]
-            col_type = col[2]
-            is_primary = "primary key" if col[5] == 1 else ""
-            schema.append(f"- {col_name} ({col_type}) {is_primary}".strip())
+        # Generate CSV
+        csv_data = parse_text_content(content)
         
-        return "\n".join(schema)
+        # Convert to DataFrame
+        df = pd.read_csv(StringIO(csv_data), keep_default_na=False)
         
+        return True, df, csv_data
+    
     except Exception as e:
-        return None
+        return False, pd.DataFrame(), str(e)
+
+def handle_upload(files):
+    """Process multiple files"""
+    all_dfs = []
+    full_content = ""
+    
+    for file in files:
+        success, df, content = process_file(file)
+        if success:
+            all_dfs.append(df)
+            full_content += f"\n\n--- {file.name} ---\n{content}"
+    
+    combined_df = pd.concat(all_dfs, ignore_index=True) if all_dfs else pd.DataFrame()
+    
+    # Generate analysis
+    analysis = analyze_content(full_content)
+    
+    return combined_df, analysis
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Advanced Text Analyzer")
+    
+    with gr.Row():
+        file_input = gr.File(
+            file_count="multiple",
+            file_types=[".txt"],
+            label="Upload Documents"
+        )
+        submit_btn = gr.Button("Analyze")
+    
+    with gr.Row():
+        data_output = gr.Dataframe(label="Structured Data")
+        json_output = gr.JSON(label="Content Analysis")
+
+    submit_btn.click(
+        handle_upload,
+        inputs=file_input,
+        outputs=[data_output, json_output]
+    )
+
+if __name__ == "__main__":
+    demo.launch()