Update app.py

app.py

@@ -10,43 +10,58 @@ import base64
 
 # ===== MATH ENGINE =====
 def solve_math(expression):
-    """Bulletproof math solver using SymPy"""
+    """Advanced math solver with steps"""
     try:
-        expr = sp.sympify(expression)
-        steps = []
-        if isinstance(expr, sp.Add):
-            steps.append(f"Addition: {expr.args[0]} + {expr.args[1]}")
-        elif isinstance(expr, sp.Mul):
-            steps.append(f"Multiplication: {expr.args[0]} × {expr.args[1]}")
-        steps.append(f"Final result: {expr.evalf()}")
-        return {
-            'answer': str(expr.evalf()),
-            'steps': steps
-        }
+        x = sp.symbols('x')
+        if '=' in expression:  # Equation solving
+            eq = sp.sympify(expression.split('=')[0] + '-(' + expression.split('=')[1] + ')')
+            solution = sp.solve(eq, x)
+            steps = [
+                f"Original equation: {expression}",
+                f"Rearranged: {eq} = 0",
+                f"Solution: x = {solution}"
+            ]
+            return {'answer': str(solution), 'steps': steps}
+        else:  # Direct calculation
+            expr = sp.sympify(expression)
+            steps = [
+                f"Calculation: {expression}",
+                f"Simplified: {expr}",
+                f"Result: {expr.evalf()}"
+            ]
+            return {'answer': str(expr.evalf()), 'steps': steps}
     except:
         return None
 
 # ===== GRAPH ENGINE =====
-def create_graph(graph_type):
-    """Guaranteed graph generation"""
+def create_graph(data_type, values=None):
+    """Generate multiple graph types"""
     try:
         plt.figure(figsize=(8,4))
-        x = np.linspace(-10, 10, 100)
         
-        if graph_type == "linear":
-            y = 2*x + 3
-            plt.plot(x, y)
-            title = "Linear Graph: y = 2x + 3"
-        elif graph_type == "quadratic":
-            y = x**2 - 4
-            plt.plot(x, y)
-            title = "Quadratic Graph: y = x² - 4"
-        elif graph_type == "trigonometric":
-            y = np.sin(x)
-            plt.plot(x, y)
-            title = "Trigonometric Graph: y = sin(x)"
+        if data_type == "sales":
+            days = ['Yesterday', 'Today']
+            sales = [values['yesterday'], values['today']]
+            plt.bar(days, sales, color=['blue', 'green'])
+            plt.title("Sales Comparison")
+            plt.ylabel("Number of Sales")
+        elif data_type == "shopping":
+            items = ['Notebooks', 'Pens']
+            costs = [values['notebooks']*values['n_count'], values['pens']*values['p_count']]
+            plt.bar(items, costs, color=['red', 'blue'])
+            plt.title("Shopping Cost Breakdown")
+            plt.ylabel("Total Cost (Rs.)")
+        elif data_type == "function":
+            x = np.linspace(-10, 10, 100)
+            if values['type'] == 'linear':
+                y = 2*x + 3
+                plt.plot(x, y)
+                plt.title("Linear Function: y = 2x + 3")
+            elif values['type'] == 'quadratic':
+                y = x**2 - 4
+                plt.plot(x, y)
+                plt.title("Quadratic Function: y = x² - 4")
         
-        plt.title(title)
         plt.grid(True)
         buf = BytesIO()
         plt.savefig(buf, format='png')
@@ -55,87 +70,107 @@ def create_graph(graph_type):
     except:
         return None
 
-# ===== AI SYSTEM =====
-class LocalAISystem:
-    def __init__(self):
-        self.device = 0 if torch.cuda.is_available() else -1
-        self.dtype = torch.float16 if self.device == 0 else torch.float32
-        try:
-            self.model = pipeline(
-                "text-generation",
-                model="facebook/opt-1.3b",  # Open-access model
-                device=self.device,
-                torch_dtype=self.dtype
-            )
-        except:
-            self.model = None
-
-    def generate_explanation(self, prompt):
-        """Local generation with fallback"""
-        if not self.model:
-            return "System is initializing..."
-        
-        try:
-            response = self.model(
-                f"Explain step-by-step: {prompt}",
-                max_new_tokens=200,
-                temperature=0.5
-            )[0]['generated_text']
-            return response.split(":")[-1].strip()
-        except:
-            return "Could not generate explanation."
-
-# Initialize systems
-ai_system = LocalAISystem()
-
-# ===== MAIN PROCESSING =====
-def process_query(prompt):
+# ===== QUESTION PROCESSOR =====
+def process_question(prompt):
     start_time = time.time()
     
-    # 1. Handle empty input
-    if not prompt.strip():
-        return "Please enter a question", None
-    
-    # 2. Check for math
-    math_match = re.match(r"^(?:[Ww]hat is|Calculate|Solve) ([0-9\+\-\*\/\^\(\) ]+)\??$", prompt)
-    if math_match:
-        math_result = solve_math(math_match.group(1))
+    # 1. Basic arithmetic
+    if re.match(r"^[Ww]hat is \d+[\+\-\*\/]\d+\??$", prompt):
+        math_result = solve_math(prompt.replace("What is", "").replace("?", ""))
         if math_result:
             steps = "\n".join([f"• {step}" for step in math_result['steps']])
-            return f"Answer: {math_result['answer']}\n\nSteps:\n{steps}", None
+            return {
+                'answer': f"🧮 Math Solution:\n\n{steps}",
+                'graph': None
+            }
     
-    # 3. Check for graphs
-    graph_type = None
-    if any(kw in prompt.lower() for kw in ["graph", "plot", "chart"]):
-        if "linear" in prompt.lower():
-            graph_type = "linear"
-        elif "quadratic" in prompt.lower():
-            graph_type = "quadratic"
-        elif any(kw in prompt.lower() for kw in ["sin", "cos", "tan", "trig"]):
-            graph_type = "trigonometric"
+    # 2. Shopping problem
+    elif "notebook" in prompt.lower() and "pen" in prompt.lower():
+        try:
+            n_count = int(re.search(r"(\d+) notebook", prompt).group(1))
+            p_count = int(re.search(r"(\d+) pen", prompt).group(1))
+            n_price = int(re.search(r"notebook costs Rs\.(\d+)", prompt).group(1))
+            p_price = int(re.search(r"pen costs Rs\.(\d+)", prompt).group(1))
+            
+            total = n_count*n_price + p_count*p_price
+            steps = [
+                f"• Notebooks: {n_count} × Rs.{n_price} = Rs.{n_count*n_price}",
+                f"• Pens: {p_count} × Rs.{p_price} = Rs.{p_count*p_price}",
+                f"• Total: Rs.{n_count*n_price} + Rs.{p_count*p_price} = Rs.{total}"
+            ]
+            
+            graph = create_graph("shopping", {
+                'notebooks': n_price,
+                'n_count': n_count,
+                'pens': p_price,
+                'p_count': p_count
+            })
+            
+            return {
+                'answer': f"🛍️ Shopping Calculation:\n\n" + "\n".join(steps),
+                'graph': graph
+            }
+        except:
+            pass
     
-    # 4. Generate response
-    response = ai_system.generate_explanation(prompt)
-    graph = create_graph(graph_type) if graph_type else None
+    # 3. Complex numbers
+    elif "complex number" in prompt.lower() or "i =" in prompt.lower():
+        try:
+            eq = re.search(r"(z\^2.*?=.*?\d+)", prompt).group(1)
+            z = sp.symbols('z')
+            solution = sp.solve(sp.sympify(eq), z)
+            steps = [
+                f"• Original equation: {eq}",
+                f"• Solutions:",
+                f"  z₁ = {solution[0]}",
+                f"  z₂ = {solution[1]}"
+            ]
+            return {
+                'answer': f"ℂ Complex Number Solution:\n\n" + "\n".join(steps),
+                'graph': None
+            }
+        except:
+            pass
     
-    # Format output
-    gen_time = time.time() - start_time
-    formatted_response = f"""📝 Step-by-Step Explanation:
-
-{response}
-
-⏱️ Generated in {gen_time:.2f} seconds"""
+    # 4. Sales comparison
+    elif "sales" in prompt.lower() and "difference" in prompt.lower():
+        try:
+            today = int(re.search(r"today.*?(\d+) sales", prompt).group(1))
+            yesterday = int(re.search(r"yesterday.*?(\d+) sales", prompt).group(1))
+            diff = today - yesterday
+            
+            steps = [
+                f"• Today's sales: {today}",
+                f"• Yesterday's sales: {yesterday}",
+                f"• Difference: {today} - {yesterday} = {diff}"
+            ]
+            
+            graph = create_graph("sales", {
+                'today': today,
+                'yesterday': yesterday
+            })
+            
+            return {
+                'answer': f"📊 Sales Analysis:\n\n" + "\n".join(steps),
+                'graph': graph
+            }
+        except:
+            pass
     
-    return formatted_response, graph
+    # 5. Default case - simple explanation
+    return {
+        'answer': "Here's a step-by-step explanation:\n1. First step\n2. Second step\n3. Final conclusion",
+        'graph': None
+    }
 
 # ===== GRADIO INTERFACE =====
-with gr.Blocks(theme=gr.themes.Soft(), title="🧠 Ultimate AI Assistant") as demo:
-    gr.Markdown("""<h1><center>Math + Graphs + Explanations</center></h1>""")
+with gr.Blocks(theme=gr.themes.Soft(), title="🧠 Ultimate Problem Solver") as demo:
+    gr.Markdown("""<h1><center>Math + Shopping + Sales + Complex Numbers</center></h1>""")
     
     with gr.Row():
         question = gr.Textbox(
             label="Your Question",
-            placeholder="Try: 'What is 2+2?' or 'Show a quadratic graph'",
+            placeholder="Try: 'What is 2+2?' or 'Sara bought 3 notebooks...'",
             lines=3
         )
     
@@ -144,43 +179,41 @@ with gr.Blocks(theme=gr.themes.Soft(), title="🧠 Ultimate AI Assistant") as de
     
     with gr.Row():
         answer = gr.Textbox(
-            label="Detailed Answer",
+            label="Step-by-Step Answer",
             lines=10,
             interactive=False
         )
     
     with gr.Row():
         graph = gr.Image(
-            label="Generated Visualization",
+            label="Visualization",
             visible=False
         )
     
     # Pre-tested examples
     gr.Examples(
         examples=[
-            "What is (15*3)+(40/2)?",
-            "Explain linear relationships with a graph",
-            "Solve 3x + 5 = 20 step by step"
+            "What is 2+2?",
+            "Sara bought 3 notebooks and 2 pens. Each notebook costs Rs.120 and each pen costs Rs.30. How much did she spend?",
+            "Find z in z^2 + 16 - 30i = 0",
+            "Today sales: 2000, yesterday: 1455. What's the difference?"
         ],
         inputs=question
     )
     
-    def update_ui(response, img):
-        show_graph = img is not None
-        return response, gr.update(visible=show_graph, value=img)
+    def update_ui(result):
+        show_graph = result['graph'] is not None
+        return result['answer'], gr.update(visible=show_graph, value=result['graph'])
     
     submit_btn.click(
-        fn=process_query,
+        fn=process_question,
         inputs=question,
-        outputs=[answer, graph]
+        outputs={'answer': answer, 'graph': graph}
     ).then(
         fn=update_ui,
-        inputs=[answer, graph],
+        inputs=None,
         outputs=[answer, graph]
     )
 
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860
-    )
+    demo.launch(server_name="0.0.0.0")