Initial commit

app.py

@@ -13,163 +13,388 @@ logger = logging.getLogger(__name__)
 logger.info("Starting application setup")
 qwen_api_key = os.getenv("QWEN_API_KEY")
 if not qwen_api_key:
-    logger.error("QWEN_API_KEY not set")
-    raise ValueError("QWEN_API_KEY is required. Set it in Spaces Secrets (Settings > Repository secrets > Add secret > Name: QWEN_API_KEY).")
-
-# تنظیم کلاینت OpenAI برای DashScope
-try:
-    client = OpenAI(
-        api_key=qwen_api_key,
-        base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
-    )
-    logger.info("Initialized OpenAI client for model qwen3-coder-plus")
-except Exception as e:
-    logger.error(f"Failed to initialize OpenAI client: {e}")
-    raise
+    logger.warning("QWEN_API_KEY not found in environment variables")
+    # اگه API Key نباشه، ادامه بده ولی خطا نده
+    client = None
+else:
+    # تنظیم کلاینت OpenAI برای DashScope
+    try:
+        client = OpenAI(
+            api_key=qwen_api_key,
+            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+            timeout=30.0
+        )
+        logger.info("✅ OpenAI client initialized successfully")
+        
+        # تست اتصال
+        try:
+            test_response = client.models.list()
+            logger.info("✅ API connection test successful")
+        except:
+            logger.warning("⚠️ API test failed but client created")
+            
+    except Exception as e:
+        logger.error(f"❌ Failed to initialize OpenAI client: {e}")
+        client = None
 
 # مسیر فایل دیتابیس
-DB_PATH = "chris.db"
+DB_PATH = "christopher_history.db"
 
 # ایجاد دیتابیس
 def init_db():
-    logger.info("Initializing database")
+    logger.info("🗄️ Initializing database")
     try:
         with sqlite3.connect(DB_PATH) as conn:
             cursor = conn.cursor()
-            cursor.execute('''CREATE TABLE IF NOT EXISTS CHRIS (
+            cursor.execute('''CREATE TABLE IF NOT EXISTS code_history (
                                 id INTEGER PRIMARY KEY AUTOINCREMENT,
-                                user_input TEXT,
-                                task_type TEXT,
-                                prompt TEXT,
-                                response TEXT,
-                                timestamp TEXT
+                                user_input TEXT NOT NULL,
+                                language TEXT NOT NULL,
+                                generated_code TEXT NOT NULL,
+                                prompt_used TEXT,
+                                timestamp TEXT NOT NULL,
+                                success BOOLEAN DEFAULT 1
                               )''')
             conn.commit()
-            logger.info("Database initialized")
+            logger.info("✅ Database initialized successfully")
     except Exception as e:
-        logger.error(f"Database error: {e}")
-        raise
+        logger.error(f"❌ Database initialization error: {e}")
 
 # ذخیره در دیتابیس
-def save_to_memory(user_input, task_type, prompt, response):
-    logger.info("Saving to database")
+def save_to_db(user_input, language, generated_code, prompt_used="", success=True):
+    logger.info("💾 Saving to database")
     try:
         with sqlite3.connect(DB_PATH) as conn:
             cursor = conn.cursor()
-            cursor.execute("INSERT INTO CHRIS (user_input, task_type, prompt, response, timestamp) VALUES (?, ?, ?, ?, ?)",
-                           (user_input, task_type, prompt, response, datetime.now().isoformat()))
+            cursor.execute("""INSERT INTO code_history 
+                            (user_input, language, generated_code, prompt_used, timestamp, success) 
+                            VALUES (?, ?, ?, ?, ?, ?)""",
+                           (user_input, language, generated_code, prompt_used, 
+                            datetime.now().isoformat(), success))
             conn.commit()
-            logger.info("Saved to DB")
+            logger.info("✅ Successfully saved to database")
     except Exception as e:
-        logger.error(f"DB Save Error: {e}")
-        pass
+        logger.error(f"❌ Database save error: {e}")
 
 # دریافت تاریخچه
-def get_history():
-    logger.info("Retrieving history from database")
+def get_history(limit=10):
+    logger.info("📜 Retrieving history from database")
     try:
         with sqlite3.connect(DB_PATH) as conn:
             cursor = conn.cursor()
-            cursor.execute("SELECT id, user_input, task_type, prompt, response, timestamp FROM CHRIS ORDER BY timestamp DESC")
+            cursor.execute("""SELECT id, user_input, language, generated_code, timestamp, success 
+                            FROM code_history 
+                            ORDER BY timestamp DESC 
+                            LIMIT ?""", (limit,))
             rows = cursor.fetchall()
+            
             if not rows:
-                return "هیچ تاریخچه‌ای موجود نیست."
-            history_text = "=== تاریخچه ===\n"
-            for row in rows:
-                history_text += f"ID: {row[0]}\n"
-                history_text += f"ورودی کاربر: {row[1]}\n"
-                history_text += f"نوع کار: {row[2]}\n"
-                history_text += f"پرامپت: {row[3]}\n"
-                history_text += f"پاسخ: {row[4]}\n"
-                history_text += f"زمان: {row[5]}\n"
-                history_text += "-" * 50 + "\n"
+                return "📝 هیچ تاریخچه‌ای موجود نیست."
+            
+            history_text = f"📋 **تاریخچه آخرین {len(rows)} درخواست:**\n\n"
+            
+            for i, row in enumerate(rows, 1):
+                status_icon = "✅" if row[5] else "❌"
+                history_text += f"**{i}. {status_icon} درخواست #{row[0]}**\n"
+                history_text += f"📝 **درخواست:** {row[1]}\n"
+                history_text += f"🔧 **زبان:** {row[2]}\n"
+                history_text += f"⏰ **زمان:** {row[4]}\n"
+                history_text += f"💻 **کد تولیدشده:**\n```{row[2].lower()}\n{row[3][:200]}{'...' if len(row[3]) > 200 else ''}\n```\n"
+                history_text += "─" * 50 + "\n\n"
+            
             return history_text
+            
     except Exception as e:
-        logger.error(f"History retrieval error: {e}")
-        return f"خطا در دریافت تاریخچه: {e}"
+        logger.error(f"❌ History retrieval error: {e}")
+        return f"خطا در دریافت تاریخچه: {str(e)}"
 
 # تولید کد
 def generate_code(text, language):
-    logger.info(f"Processing input: {text}, language: {language}")
+    logger.info(f"🚀 Generating code for: {text[:50]}... in {language}")
+    
+    if client is None:
+        error_msg = "❌ خطا: اتصال به API برقرار نشد. لطفاً API Key را بررسی کنید."
+        error_code = f"# خطا در اتصال به سرویس\n# درخواست: {text}\nprint('لطفاً API Key را در تنظیمات Hugging Face اضافه کنید')"
+        save_to_db(text, language, error_code, error_msg, success=False)
+        return error_msg, error_code
+    
     try:
-        prompt = f"Write a complete, correct, and well-explained code in {language} to: {text}"
-        logger.info(f"Generated prompt: {prompt}")
-        response = client.chat.completions.create(
-            model="qwen3-coder-plus",
-            messages=[
-                {"role": "system", "content": "You are a coding assistant that generates complete and well-explained code."},
-                {"role": "user", "content": prompt}
-            ],
-            max_tokens=1024,
-            temperature=0.7,
-            top_p=0.8
-        )
-        code_output = response.choices[0].message.content.strip()
-        
-        # استخراج کد از خروجی (در صورت وجود بلاک کد)
-        lines = code_output.split('\n')
-        code = []
-        is_code = False
-        for line in lines:
-            if line.startswith("```"):
-                is_code = not is_code
+        # لیست مدل‌های مختلف برای تست
+        models_to_try = [
+            "qwen2.5-coder-32b-instruct",
+            "qwen-coder-plus", 
+            "qwen2.5-coder-7b-instruct"
+        ]
+        
+        system_prompt = f"""You are an expert {language} programmer. 
+Generate clean, well-documented, and executable code with proper comments.
+Always include error handling where appropriate."""
+        
+        user_prompt = f"""Create a complete {language} program that: {text}
+
+Requirements:
+- Write clean, readable code
+- Include helpful comments (both English and Persian if helpful)
+- Add proper error handling
+- Make sure the code is executable
+- Follow {language} best practices
+
+Please provide only the code, no extra explanations."""
+        
+        code_generated = False
+        response_content = ""
+        model_used = ""
+        
+        # تلاش با مدل‌های مختلف
+        for model in models_to_try:
+            try:
+                logger.info(f"🔄 Trying model: {model}")
+                response = client.chat.completions.create(
+                    model=model,
+                    messages=[
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": user_prompt}
+                    ],
+                    max_tokens=1500,
+                    temperature=0.3,
+                )
+                
+                response_content = response.choices[0].message.content.strip()
+                model_used = model
+                code_generated = True
+                logger.info(f"✅ Successfully used model: {model}")
+                break
+                
+            except Exception as model_error:
+                logger.warning(f"⚠️ Model {model} failed: {model_error}")
                 continue
-            elif is_code:
-                code.append(line)
         
-        final_code = "\n".join(code).strip() if code else code_output
-        if not final_code:
-            logger.warning("Generated code is empty")
-            final_code = "خطا: کد تولیدشده خالی است"
+        if not code_generated:
+            error_msg = "❌ همه مدل‌ها شکست خوردند"
+            error_code = f"# خطا در تولید کد\n# درخواست: {text}\nprint('خطا در دسترسی به مدل‌های AI')"
+            save_to_db(text, language, error_code, error_msg, success=False)
+            return error_msg, error_code
+        
+        # پاک‌سازی کد از markdown
+        final_code = clean_code_output(response_content)
+        
+        if not final_code or final_code.strip() == "":
+            final_code = f"# کد برای: {text}\n# زبان: {language}\nprint('خوش آمدید!')"
+        
+        # ذخیره در دیتابیس
+        save_to_db(text, language, final_code, f"Model: {model_used}", success=True)
+        
+        logger.info("✅ Code generated and saved successfully")
+        return f"✅ کد با موفقیت تولید شد (مدل: {model_used})", final_code
         
-        logger.info(f"Generated code: {final_code}")
-        return prompt, final_code
     except Exception as e:
-        logger.error(f"Code generation error: {e}")
-        return f"Error prompt: {text}", f"Code generation error: {e}"
+        logger.error(f"❌ Code generation error: {e}")
+        error_code = f"# خطا در تولید کد: {str(e)}\n# درخواست: {text}\n# زبان: {language}\nprint('متأسفانه خطایی رخ داد')"
+        save_to_db(text, language, error_code, str(e), success=False)
+        return f"❌ خطا: {str(e)}", error_code
+
+def clean_code_output(code_text):
+    """پاک‌سازی کد از markdown و متن اضافی"""
+    if not code_text:
+        return ""
+    
+    # حذف markdown code blocks
+    if "```" in code_text:
+        import re
+        # پیدا کردن همه بلاک‌های کد
+        code_blocks = re.findall(r'```(?:\w+\n)?(.*?)```', code_text, re.DOTALL)
+        if code_blocks:
+            # انتخاب بزرگترین بلاک کد
+            largest_block = max(code_blocks, key=len)
+            return largest_block.strip()
+    
+    return code_text.strip()
 
-# تابع اصلی
-def christopher(user_input, language, show_history):
-    logger.info(f"Processing input: {user_input}, language: {language}, show_history: {show_history}")
+# تابع اصلی برای پردازش درخواست
+def process_request(user_input, language, show_history):
+    logger.info(f"📨 Processing request - Language: {language}, Show History: {show_history}")
+    
+    if not user_input or not user_input.strip():
+        return "❌ لطفاً توضیحی برای برنامه وارد کنید.", get_history() if show_history else ""
+    
     try:
-        task_type = "تولید کد"
-        prompt, response = generate_code(user_input, language)
-        if "error" in response.lower():
-            history = get_history() if show_history else ""
-            return response, history
-        save_to_memory(user_input, task_type, prompt, response)
+        # تولید کد
+        status_message, generated_code = generate_code(user_input, language)
+        
+        # دریافت تاریخچه در صورت درخواست
         history = get_history() if show_history else ""
-        return response, history
+        
+        logger.info("✅ Request processed successfully")
+        return generated_code, history, status_message
+        
     except Exception as e:
-        logger.error(f"Processing error: {e}")
+        logger.error(f"❌ Processing error: {e}")
+        error_response = f"# متأسفانه خطایی رخ داد: {str(e)}\nprint('لطفاً مجدداً تلاش کنید')"
         history = get_history() if show_history else ""
-        return f"خطا: {e}", history
+        return error_response, history, f"❌ خطا: {str(e)}"
 
 # رابط گرادیو
-def gradio_ui(user_input, language, show_history):
-    code, history = christopher(user_input, language, show_history)
-    return code, history
+def create_gradio_interface():
+    with gr.Blocks(
+        theme=gr.themes.Soft(),
+        title="کریستوفر - دستیار کدنویسی",
+        css="""
+        .gradio-container {
+            font-family: 'Tahoma', sans-serif;
+            direction: rtl;
+        }
+        .status-success { color: #22c55e; font-weight: bold; }
+        .status-error { color: #ef4444; font-weight: bold; }
+        """
+    ) as demo:
+        
+        gr.Markdown("""
+        # 🤖 کریستوفر - دستیار هوشمند کدنویسی
+        ### 🚀 با قدرت مدل‌های Qwen2.5-Coder
+        
+        توضیح برنامه‌ای که می‌خواهید را به فارسی وارد کنید و زبان برنامه‌نویسی مورد نظر را انتخاب کنید.
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                user_input = gr.Textbox(
+                    label="📝 توضیح برنامه به فارسی",
+                    placeholder="مثال: یک تابع برای محاسبه اعداد فیبوناچی تا عدد n",
+                    lines=4,
+                    max_lines=8
+                )
+                
+                with gr.Row():
+                    language = gr.Dropdown(
+                        choices=["Python", "JavaScript", "Java", "C++", "C#", "Go", "Rust", "PHP", "TypeScript"],
+                        label="🔧 زبان برنامه‌نویسی",
+                        value="Python"
+                    )
+                    
+                    show_history = gr.Checkbox(
+                        label="📋 نمایش تاریخچه",
+                        value=False
+                    )
+                
+                generate_btn = gr.Button("🚀 تولید کد", variant="primary", size="lg")
+        
+        # نمایش وضعیت
+        status_display = gr.Markdown("آماده برای تولید کد...")
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                code_output = gr.Code(
+                    label="💻 کد تولیدشده",
+                    language="python",
+                    interactive=False,
+                    show_label=True
+                )
+            
+            with gr.Column(scale=2, visible=False) as history_column:
+                history_output = gr.Markdown(
+                    label="📜 تاریخچه درخواست‌ها",
+                    value="تاریخچه‌ای موجود نیست."
+                )
+        
+        # تنظیم رویدادها
+        def update_interface(user_input, language, show_history):
+            code, history, status = process_request(user_input, language, show_history)
+            
+            # تنظیم نمایش تاریخچه
+            history_visibility = gr.update(visible=show_history)
+            
+            return (
+                code,  # کد تولیدشده
+                history if show_history else "",  # تاریخچه
+                status,  # وضعیت
+                history_visibility  # نمایش ستون تاریخچه
+            )
+        
+        generate_btn.click(
+            fn=update_interface,
+            inputs=[user_input, language, show_history],
+            outputs=[code_output, history_output, status_display, history_column]
+        )
+        
+        show_history.change(
+            fn=lambda x: gr.update(visible=x),
+            inputs=[show_history],
+            outputs=[history_column]
+        )
+        
+        # مثال‌های نمونه
+        gr.Markdown("""
+        ### 💡 مثال‌های نمونه درخواست:
+        
+        🔢 **ریاضی:** "یک تابع برای محاسبه فاکتوریل عدد"  
+        📊 **داده:** "برنامه مرتب‌سازی لیست اعداد به صورت صعودی"  
+        🎮 **بازی:** "یک بازی حدس عدد ساده"  
+        📁 **فایل:** "تابعی برای خواندن و نوشتن فایل متنی"  
+        🌐 **وب:** "یک صفحه HTML ساده با فرم ورودی"  
+        """)
+        
+        # نمایش آمار دیتابیس
+        with gr.Row():
+            stats_btn = gr.Button("📊 نمایش آمار", size="sm")
+            stats_output = gr.Textbox(label="📈 آمار دیتابیس", visible=False)
+            
+            def show_stats():
+                try:
+                    with sqlite3.connect(DB_PATH) as conn:
+                        cursor = conn.cursor()
+                        cursor.execute("SELECT COUNT(*) FROM code_history")
+                        total = cursor.fetchone()[0]
+                        
+                        cursor.execute("SELECT COUNT(*) FROM code_history WHERE success = 1")
+                        successful = cursor.fetchone()[0]
+                        
+                        cursor.execute("SELECT language, COUNT(*) FROM code_history GROUP BY language ORDER BY COUNT(*) DESC")
+                        lang_stats = cursor.fetchall()
+                        
+                        stats = f"📊 **آمار کلی:**\n"
+                        stats += f"🔢 **کل درخواست‌ها:** {total}\n"
+                        stats += f"✅ **موفق:** {successful}\n"
+                        stats += f"❌ **ناموفق:** {total - successful}\n\n"
+                        stats += f"🔧 **زبان‌های پربازدید:**\n"
+                        
+                        for lang, count in lang_stats:
+                            stats += f"• {lang}: {count} درخواست\n"
+                        
+                        return gr.update(value=stats, visible=True)
+                except:
+                    return gr.update(value="خطا در نمایش آمار", visible=True)
+            
+            stats_btn.click(
+                fn=show_stats,
+                inputs=[],
+                outputs=[stats_output]
+            )
+    
+    return demo
 
-if __name__ == "__main__":
-    logger.info("Starting application")
+# تابع اصلی برنامه
+def main():
+    logger.info("🚀 Starting Christopher - Code Generation Assistant")
+    
     try:
+        # مقداردهی اولیه دیتابیس
         init_db()
-        logger.info("Launching Gradio interface")
-        iface = gr.Interface(
-            fn=gradio_ui,
-            inputs=[
-                gr.Textbox(label="توضیح برنامه به فارسی (مثال: یک تابع اعداد زوج)"),
-                gr.Dropdown(choices=["Python", "JavaScript", "Java", "C++"], label="زبان برنامه‌نویسی"),
-                gr.Checkbox(label="نمایش تاریخچه درخواست‌ها", value=False)
-            ],
-            outputs=[
-                gr.Textbox(label="کد تولیدشده"),
-                gr.Textbox(label="تاریخچه درخواست‌ها")
-            ],
-            title="کریستوفر - دستیار کدنویسی",
-            description="توضیح برنامه را به فارسی وارد کنید و زبان برنامه‌نویسی را انتخاب کنید. برای نمایش تاریخچه، گزینه مربوطه را تیک بزنید."
+        
+        # ایجاد رابط گرادیو
+        demo = create_gradio_interface()
+        
+        logger.info("🌐 Launching Gradio interface")
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            show_error=True,
+            show_api=False
         )
-        iface.launch(server_name="0.0.0.0", server_port=7860)
+        
     except Exception as e:
-        logger.error(f"Startup error: {e}")
-        raise
+        logger.error(f"❌ Application startup error: {e}")
+        raise
+
+if __name__ == "__main__":
+    main()