Update app.py

app.py

@@ -1,301 +1,159 @@
 # ------------------------------------------------------------
-# AGI + Safe Math + Awareness + 100% Accurate Math Solver (Best-Practice)
-# Hugging Face Spaces Version – Fixed readonly Error
+# AGI + 100% Accurate Math Solver + Multilingual Smart Reply
+# يرد باللغة نفسها (عربي/إنجليزي) + Terminal Style
 # ------------------------------------------------------------
 
 import gradio as gr
 import torch
-import math
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import sympy as sp
+from sympy import symbols, Eq, solve, diff, integrate
+from z3 import Solver, Int, sat
 import re
-import logging
 from collections import deque
-from transformers import GPT2Tokenizer, GPT2LMHeadModel
-import sympy as sp
-from sympy import symbols, Eq, solve, diff, integrate, simplify, sqrt, sin, cos, tan, log, exp
-from z3 import Solver, Int, Real, sat
-import traceback
 
-# ---------- 1. Logging ----------
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s | %(levelname)s | %(message)s",
-    encoding="utf-8"
+# ---------- تحميل نموذج ذكي حديث (يدعم العربية والإنجليزية) ----------
+model_name = "HuggingFaceH4/zephyr-7b-beta"  # أفضل نموذج مجاني 2025
+# بديل ممتاز: "meta-llama/Llama-3.2-3B-Instruct"
+
+print("جاري تحميل النموذج الذكي... (مرة واحدة فقط)")
+tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype=torch.float16,
+    device_map="auto",
+    trust_remote_code=True,
+    low_cpu_mem_usage=True
 )
-
-# ---------- 2. Load GPT-2 (once) ----------
-model_name = "gpt2"
-print("جاري تحميل GPT-2... (مرة واحدة فقط)")
-tokenizer = GPT2Tokenizer.from_pretrained(model_name)
-model = GPT2LMHeadModel.from_pretrained(model_name)
 model.eval()
 
-# ---------- 3. Safe math whitelist ----------
-SAFE_MATH = {
-    "sin": lambda x: math.sin(math.radians(x)),
-    "cos": lambda x: math.cos(math.radians(x)),
-    "tan": lambda x: math.tan(math.radians(x)),
-    "sqrt": math.sqrt,
-    "log": math.log,
-    "exp": math.exp,
-    "abs": abs,
-}
-
-# ---------- 4. Bad-word filter ----------
-BAD_WORDS = {
-    "كلب", "حمار", "غبي", "قذر", "بذيء", "حيوان", "نذل",
-    "idiot", "stupid", "fuck", "shit", "damn", "hell"
-}
+# ---------- ذاكرة السياق ----------
+context = deque(maxlen=6)
 
-# ---------- 5. Context memory (last 3 turns) ----------
-context = deque(maxlen=3)
+# ---------- كشف المسائل الرياضية ----------
+MATH_PATTERN = re.compile(r"[0-9+\-*/().^=]|sin|cos|tan|sqrt|log|exp|اشتق|تكامل|حل|d/dx|integral", re.I)
 
-# ---------- 6. Math pattern ----------
-MATH_PATTERN = re.compile(r"[0-9+\-*/().^=]|sin|cos|tan|sqrt|log|exp|abs|تكامل|اشتق|حل", re.I)
-
-def is_math_expression(text: str) -> bool:
+def is_math_question(text: str) -> bool:
     return bool(MATH_PATTERN.search(text))
 
-# ---------- 7. Safe calculator (basic) ----------
-def safe_eval(expr: str):
-    expr = expr.strip().replace("^", "**").replace(" ", "")
-    allowed = set("0123456789.+-*/()**")
-    for c in expr:
-        if c not in allowed and not any(f in expr.lower() for f in SAFE_MATH):
-            return None
-    try:
-        result = eval(expr, {"__builtins__": {}}, SAFE_MATH)
-        if abs(result) > 1e12:
-            return None
-        return result
-    except:
-        return None
-
-# ---------- 8. Bad-word detection ----------
-def contains_bad_word(text: str) -> bool:
-    lowered = text.lower()
-    return any(word in lowered for word in BAD_WORDS)
-
-# ---------- 9. Advanced Math Solver (100% Accurate, No Training) ----------
+# ---------- حل المسائل الرياضية بدقة 100% ----------
 def advanced_math_solver(question: str):
-    """حل أي مشكلة رياضية بدقة 100% باستخدام SymPy + Z3"""
-    question = question.strip()
-    result = {"answer": None, "steps": [], "type": "unknown", "success": False}
-
+    x = symbols('x')
     try:
-        # --- 1. جبر: حل المعادلات ---
-        if any(op in question for op in ["=", "حل", "solve"]):
-            if "x" in question or "y" in question:
-                # استخراج المعادلة
-                eq_part = re.sub(r"[^=0-9xXyY\+\-\*/\^\(\)]", "", question)
-                if "=" in eq_part:
-                    left, right = eq_part.split("=", 1)
-                    x = symbols('x')
-                    eq = Eq(sp.sympify(left), sp.sympify(right))
-                    sol = solve(eq, x)
-                    result["answer"] = sol
-                    result["steps"] = [
-                        f"المعادلة: {left} = {right}",
-                        f"نقل الطرفين: {eq}",
-                        f"الحل: x = {sol}"
-                    ]
-                    result["type"] = "algebra"
-                    result["success"] = True
-                    return result
-
-        # --- 2. تفاضل ---
-        elif any(kw in question for kw in ["اشتق", "مشتقة", "d/dx"]):
-            expr_match = re.search(r"اشتق\s+(.+)", question, re.I)
-            if expr_match:
-                expr = sp.sympify(expr_match.group(1))
-                x = symbols('x')
-                deriv = diff(expr, x)
-                result["answer"] = deriv
-                result["steps"] = [
-                    f"الدالة: f(x) = {expr}",
-                    f"المشتقة: f'(x) = {deriv}"
-                ]
-                result["type"] = "calculus"
-                result["success"] = True
-                return result
-
-        # --- 3. تكامل ---
-        elif any(kw in question for kw in ["تكامل", "∫", "integral"]):
-            expr_match = re.search(r"تكامل\s+(.+)", question, re.I)
-            if expr_match:
-                expr = sp.sympify(expr_match.group(1))
-                x = symbols('x')
-                integ = integrate(expr, x)
-                result["answer"] = integ
-                result["steps"] = [
-                    f"الدالة: {expr}",
-                    f"التكامل: ∫{expr} dx = {integ} + C"
-                ]
-                result["type"] = "calculus"
-                result["success"] = True
-                return result
-
-        # --- 4. استدلال منطقي (Z3) ---
-        elif any(kw in question for kw in ["إذا", "فإن", "و", "أو"]):
-            s = Solver()
-            a, b = Int('a'), Int('b')
-            if "a أكبر من b" in question:
-                s.add(a > b)
-            if "a + b = 10" in question:
-                s.add(a + b == 10)
-            if s.check() == sat:
-                m = s.model()
-                result["answer"] = f"a = {m[a]}, b = {m[b]}"
-                result["steps"] = ["تم بناء النموذج المنطقي", "الحل موجود"]
-                result["success"] = True
-                result["type"] = "logic"
-                return result
-
-        # --- 5. حسابات بسيطة (fallback) ---
-        else:
-            calc = safe_eval(question)
-            if calc is not None:
-                result["answer"] = calc
-                result["steps"] = [f"حساب: {question} = {calc}"]
-                result["success"] = True
-                result["type"] = "basic"
-                return result
+        question = question.strip().replace("^", "**")
+        
+        # حل المعادلات
+        if "=" in question and ("حل" in question or "solve" in question.lower() or "x" in question):
+            eq = question.split("=")
+            if len(eq) == 2:
+                left = sp.sympify(eq[0], locals={'x': x})
+                right = sp.sympify(eq[1], locals={'x': x})
+                sol = solve(Eq(left, right), x)
+                return f"**الحل:** x = {sol}", f"المعادلة: {left} = {right}\nالحل: x = {sol}"
+
+        # اشتقاق
+        if any(k in question for k in ["اشتق", "مشتقة", "d/dx", "derivative"]):
+            expr_str = re.sub(r".*اشتق\s+|\s.*", "", question, flags=re.I)
+            expr = sp.sympify(expr_str or question)
+            deriv = diff(expr, x)
+            return f"**المشتقة:** {deriv}", f"الدالة: {expr}\nالمشتقة: {deriv}"
+
+        # تكامل
+        if any(k in question for k in ["تكامل", "integral", "∫"]):
+            expr_str = re.sub(r".*تكامل\s+|\s.*", "", question, flags=re.I)
+            expr = sp.sympify(expr_str or question)
+            integ = integrate(expr, x)
+            return f"**التكامل:** ∫{expr} dx = {integ} + C", f"الدالة: {expr}\nالتكامل: {integ} + C"
+
+        # حساب بسيط
+        result = sp.sympify(question)
+        return f"**النتيجة:** {result}", f"حساب: {question} = {result}"
 
     except Exception as e:
-        logging.error(f"Math solver error: {traceback.format_exc()}")
-        result["steps"].append(f"خطأ داخلي: {str(e)}")
-
-    return result
-
-# ---------- 10. GPT-2 generation ----------
-def gpt2_reply(user_text: str) -> str:
-    prompt_lines = []
-    for u, a in context:
-        prompt_lines.append(f"User: {u}\nAGI: {a}")
-    prompt_lines.append(f"User: {user_text}\nAGI:")
-    prompt = "\n".join(prompt_lines)
-
-    inputs = tokenizer.encode(prompt, return_tensors="pt", truncation=True, max_length=512)
-    with torch.no_grad():
-        outputs = model.generate(
-            inputs,
-            max_length=inputs.shape[1] + 100,
-            pad_token_id=tokenizer.eos_token_id,
-            do_sample=True,
-            temperature=0.7,
-            top_p=0.9,
-            top_k=50,
-        )
+        return None, f"خطأ في الحل: {str(e)}"
+
+# ---------- رد ذكي متعدد اللغات (يرد بنفس لغة السؤال) ----------
+def smart_reply(user_text: str) -> str:
+    messages = [{"role": "system", "content": "أنت مساعد ذكي يرد بنفس لغة المستخدم (عربي أو إنجليزي) بأسلوب واضح ومفيد."}]
+    
+    for user_msg, bot_msg in context:
+        messages.append({"role": "user", "content": user_msg})
+        messages.append({"role": "assistant", "content": bot_msg})
+    
+    messages.append({"role": "user", "content": user_text})
+
+    inputs = tokenizer.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_tensors="pt"
+    ).to(model.device)
+
+    outputs = model.generate(
+        inputs,
+        max_new_tokens=300,
+        temperature=0.7,
+        top_p=0.9,
+        do_sample=True,
+        pad_token_id=tokenizer.eos_token_id
+    )
+    
     reply = tokenizer.decode(outputs[0], skip_special_tokens=True)
-    reply = reply.split("AGI:")[-1].strip()
+    reply = reply.split("assistant")[-1].strip()
     return reply
 
-# ---------- Terminal-style Interface ----------
-def process_input(user_input, output_text):
+# ---------- المعالجة الرئيسية ----------
+def process(message, html_output):
     global context
 
-    if user_input.lower() in ["exit", "quit", "خروج"]:
-        reply = "تم الإغلاق. شكرًا!"
-        output_text += f"\nأنت: {user_input}\nAGI: {reply}\n"
-        return output_text, ""
-
-    logging.info(f"USER: {user_input}")
+    if not message.strip():
+        return html_output, ""
 
-    if contains_bad_word(user_input):
-        reply = "AGI: آسف، لا أقبل اللغة السيئة.\n"
-        logging.warning("Bad word detected")
-    elif is_math_expression(user_input):
-        print("AGI: جاري حل المسألة بدقة 100%...")
-        math_result = advanced_math_solver(user_input)
-        if math_result["success"]:
-            reply = f"AGI: الإجابة: {math_result['answer']}\n"
-            if math_result["steps"]:
-                reply += "الخطوات:\n"
-                for step in math_result["steps"]:
-                    reply += f"   • {step}\n"
-            print()
-            logging.info(f"MATH SUCCESS: {math_result['answer']} | Type: {math_result['type']}")
-            context.append((user_input, str(math_result["answer"])))
+    user_line = f"<span style='color:#00ff88'>أنت:</span> {message}<br>"
+    
+    if is_math_question(message):
+        math_answer, steps = advanced_math_solver(message)
+        if math_answer:
+            reply = f"<span style='color:#ffff00'>{math_answer}</span><br><span style='color:#88ccff'>{steps}</span>"
+            context.append((message, math_answer))
         else:
-            reply = "AGI: لم أتمكن من حلها رمزيًا، سأستخدم الذكاء العام...\n"
+            reply = f"<span style='color:#ff8888'>لم أتمكن من حلها رياضياً، سأجيب ذكياً...</span><br>{smart_reply(message)}"
+            context.append((message, "رد ذكي"))
     else:
-        reply = gpt2_reply(user_input)
-        logging.info(f"AGI REPLY: {reply}")
-        context.append((user_input, reply))
-
-    output_text += f"\nأنت: {user_input}\nAGI: {reply}"
-    return output_text, ""
+        reply = smart_reply(message)
+        context.append((message, reply))
 
-# ---------- Gradio UI (Fixed: No readonly, Use HTML for Output) ----------
-print("AGI + 100% Accurate Math Solver (Best-Practice) جاهز!")
-print("أمثلة:")
-print("   حل x^3 - 6x^2 + 11x - 6 = 0")
-print("   اشتق x^2 + sin(x)")
-print("   تكامل x^2 + 2x")
-print("   إذا كان a أكبر من b و a + b = 10، فما قيم a و b؟")
-print("   5 + 3 * 2")
-print("اكتب 'exit' للخروج.\n")
+    new_html = html_output + user_line + f"<span style='color:#00ffff'>AGI:</span> {reply}<br><br>"
+    return new_html, ""
 
-with gr.Blocks(title="AGI Math Solver Terminal") as demo:
-    # Header
+# ---------- واجهة Terminal (بدون أي أخطاء) ----------
+with gr.Blocks(title="AGI Terminal") as demo:
     gr.HTML("""
-    <div style="text-align:center; padding:20px; background-color:#000; color:#00ff00; border-radius:15px; margin-bottom:20px; font-family:monospace;">
-        <h1>AGI + 100% Accurate Math Solver – Terminal Mode</h1>
-        <p>اكتب سؤالك أو مسألة رياضية واضغط Enter</p>
+    <div style="text-align:center; padding:20px; background:#000; color:#00ff00; font-family:monospace; border-bottom:3px solid #00ff00;">
+        <h1>AGI + حل رياضيات دقيق 100% + ذكاء متعدد اللغات</h1>
+        <p>اكتب أي شيء: مسألة رياضية أو سؤال عادي (عربي أو إنجليزي) واضغط Enter</p>
     </div>
     """)
 
-    # Output as HTML (no readonly error)
-    output_html = gr.HTML(
-        value="""
-        <pre style="background:#000; color:#00ff00; padding:10px; height:400px; overflow-y:scroll; font-family:monospace;">
-AGI: AGI + 100% Accurate Math Solver جاهز!<br>
-أمثلة:<br>
-  • حل x^3 - 6x^2 + 11x - 6 = 0<br>
-  • اشتق x^2 + sin(x)<br>
-  • تكامل x^2 + 2x<br>
-  • 5 + 3 * 2<br>
-اكتب 'exit' للخروج.
-        </pre>
-        """
-    )
+    terminal = gr.HTML(value="""
+    <pre style="background:#000; color:#00ff00; padding:15px; height:500px; overflow-y:auto; font-family:monospace; border:2px solid #00ff00; border-radius:10px;">
+<span style="color:#ffff00">AGI جاهز! مرحباً بك</span>
+<span style="color:#88ccff">جرب:</span>
+  • حل x² - 5x + 6 = 0
+  • اشتق x³ + sin(x)
+  • What is the sun?
+  • Who invented electricity?
+    </pre>
+    """)
 
     msg = gr.Textbox(
-        label="أنت: ",
-        placeholder="اكتب هنا ثم اضغط Enter...",
-        lines=1
+        placeholder="اكتب هنا واضغط Enter...",
+        lines=1,
+        label="",
+        container=False
     )
 
-    # Process input and update HTML output
-    def update_output(message, current_html):
-        if message.lower() in ["exit", "quit", "خروج"]:
-            reply = "تم الإغلاق. شكرًا!"
-            new_html = current_html + f"<br><span style='color:#00ff00'>أنت:</span> {message}<br><span style='color:#ffff00'>AGI:</span> {reply}"
-        else:
-            # Your original logic
-            if contains_bad_word(message):
-                reply = "AGI: آسف، لا أقبل اللغة السيئة."
-            elif is_math_expression(message):
-                math_result = advanced_math_solver(message)
-                if math_result["success"]:
-                    reply = f"AGI: الإجابة: {math_result['answer']}<br>"
-                    if math_result["steps"]:
-                        reply += "الخطوات:<br>"
-                        for step in math_result["steps"]:
-                            reply += f"   • {step}<br>"
-                    context.append((message, str(math_result["answer"])))
-                else:
-                    reply = "AGI: لم أتمكن من حلها رمزيًا، سأستخدم الذكاء العام..."
-            else:
-                reply = gpt2_reply(message)
-                context.append((message, reply))
-
-            new_html = current_html + f"<br><span style='color:#00ff00'>أنت:</span> {message}<br><span style='color:#ffff00'>AGI:</span> {reply}"
-        
-        # Return updated HTML
-        return gr.update(value=new_html)
-
-    msg.submit(update_output, [msg, output_html], output_html)
-    msg.submit(lambda x: "", outputs=[msg])  # Clear input after submit
+    msg.submit(process, [msg, terminal], [terminal, msg])
 
 demo.launch(
     share=True,