Initial commit

app.py

@@ -9,39 +9,39 @@ from openai import OpenAI
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# تنظیم API Key برای OpenAI
+# تنظیم API Key
 logger.info("Starting application setup")
-openai_api_key = os.getenv("OPENAI_API_KEY")
-if not openai_api_key:
-    logger.warning("OPENAI_API_KEY not found in environment variables")
-    client = None
-else:
-    try:
-        client = OpenAI(
-            api_key=openai_api_key,
-            timeout=30.0
-        )
-        logger.info("✅ OpenAI client initialized successfully")
-        
-        # تست اتصال
-        try:
-            test_response = client.models.list()
-            logger.info("✅ API connection test successful")
-        except Exception as e:
-            logger.warning(f"⚠️ API test failed but client created: {e}")
-            
-    except Exception as e:
-        logger.error(f"❌ Failed to initialize OpenAI client: {e}")
-        client = None
+openrouter_api_key = "qwen_key"
+if not openrouter_api_key:
+    logger.error("❌ OPENROUTER_API_KEY not set")
+    raise ValueError("❌ OPENROUTER_API_KEY is required. For local run, set it as an environment variable. For Spaces, set it in Settings > Repository secrets > Add secret > Name: OPENROUTER_API_KEY.")
 
-# مسیر فایل دیتابیس
-DB_PATH = "christopher_history.db"
+# تنظیم کلاینت OpenAI برای OpenRouter
+try:
+    client = OpenAI(
+        base_url="https://openrouter.ai/api/v1",
+        api_key=openrouter_api_key
+    )
+    # تست API Key
+    test_response = client.chat.completions.create(
+        model="qwen/qwen3-coder:free",
+        messages=[{"role": "user", "content": "test"}],
+        max_tokens=10,
+        extra_headers={
+            "HTTP-Referer": "https://my-christopher-app.com",
+            "X-Title": "Christopher Coding Assistant"
+        }
+    )
+    logger.info("✅ Initialized OpenAI client and API key validated for model qwen/qwen3-coder:free")
+except Exception as e:
+    logger.error(f"❌ Failed to initialize OpenAI client or validate API key: {e}")
+    raise
 
 # ایجاد دیتابیس
 def init_db():
     logger.info("🗄️ Initializing database")
     try:
-        with sqlite3.connect(DB_PATH) as conn:
+        with sqlite3.connect("chris.db") as conn:
             cursor = conn.cursor()
             cursor.execute('''CREATE TABLE IF NOT EXISTS code_history (
                                 id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -56,341 +56,134 @@ def init_db():
             logger.info("✅ Database initialized successfully")
     except Exception as e:
         logger.error(f"❌ Database initialization error: {e}")
+        raise
 
 # ذخیره در دیتابیس
-def save_to_db(user_input, language, generated_code, prompt_used="", success=True):
-    logger.info("💾 Saving to database")
+def save_to_memory(user_input, language, prompt, generated_code, success=True):
+    logger.info("Saving to database")
     try:
-        with sqlite3.connect(DB_PATH) as conn:
+        with sqlite3.connect("chris.db") as conn:
             cursor = conn.cursor()
-            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))
+            cursor.execute('''INSERT INTO code_history (user_input, language, generated_code, prompt_used, timestamp, success)
+                             VALUES (?, ?, ?, ?, ?, ?)''',
+                          (user_input, language, generated_code, prompt, datetime.now().isoformat(), success))
             conn.commit()
-            logger.info("✅ Successfully saved to database")
+            logger.info("✅ Saved to database")
     except Exception as e:
         logger.error(f"❌ Database save error: {e}")
 
 # دریافت تاریخچه
-def get_history(limit=10):
-    logger.info("📜 Retrieving history from database")
+def get_history():
+    logger.info("Retrieving history from database")
     try:
-        with sqlite3.connect(DB_PATH) as conn:
+        with sqlite3.connect("chris.db") as conn:
             cursor = conn.cursor()
-            cursor.execute("""SELECT id, user_input, language, generated_code, timestamp, success 
-                            FROM code_history 
-                            ORDER BY timestamp DESC 
-                            LIMIT ?""", (limit,))
+            cursor.execute("SELECT id, user_input, language, generated_code, prompt_used, timestamp, success FROM code_history ORDER BY timestamp DESC")
             rows = cursor.fetchall()
-            
             if not rows:
-                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 = "=== تاریخچه ===\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[4] or 'بدون پرامپت'}\n"
+                history_text += f"کد تولیدشده: {row[3]}\n"
+                history_text += f"زمان: {row[5]}\n"
+                history_text += f"موفقیت: {'بله' if row[6] else 'خیر'}\n"
+                history_text += "-" * 50 + "\n"
             return history_text
-            
     except Exception as e:
         logger.error(f"❌ History retrieval error: {e}")
-        return f"خطا در دریافت تاریخچه: {str(e)}"
+        return f"خطا در دریافت تاریخچه: {e}"
 
 # تولید کد
-def generate_code(text, 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 را در تنظیمات OpenAI اضافه کنید')"
-        save_to_db(text, language, error_code, error_msg, success=False)
-        return error_msg, error_code
-    
+def generate_code(user_input, language):
+    logger.info(f"Processing input: {user_input}, language: {language}")
     try:
-        # لیست مدل‌های OpenAI برای تست
-        models_to_try = [
-            "gpt-4o",
-            "gpt-3.5-turbo"
-        ]
-        
-        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}")
+        # پرامپت مستقیماً ورودی کاربر با زبان
+        prompt = f"{user_input} in {language}"
+        logger.info(f"Generated prompt: {prompt}")
+        response = client.chat.completions.create(
+            model="qwen/qwen3-coder:free",
+            messages=[
+                {"role": "system", "content": f"You are a coding assistant that generates complete and well-explained code in {language}."},
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=1024,
+            temperature=0.7,
+            top_p=0.8,
+            extra_headers={
+                "HTTP-Referer": "https://my-christopher-app.com",
+                "X-Title": "Christopher Coding Assistant"
+            },
+            extra_body={}
+        )
+        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
                 continue
-        
-        if not code_generated:
-            error_msg = "❌ همه مدل‌ها شکست خوردند"
-            error_code = f"# خطا در تولید کد\n# درخواست: {text}\nprint('خطا در دسترسی به مدل‌های OpenAI')"
-            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
-        
+            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 = "خطا: کد تولیدشده خالی است"
+            save_to_memory(user_input, language, prompt, final_code, success=False)
+            return prompt, final_code
+        
+        logger.info(f"Generated code: {final_code}")
+        save_to_memory(user_input, language, prompt, final_code)
+        return prompt, final_code
     except Exception as 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()
+        save_to_memory(user_input, language, prompt, str(e), success=False)
+        return prompt, f"خطا در تولید کد: {e}"
 
-# تابع اصلی برای پردازش درخواست
-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 "", ""
-    
+# تابع اصلی
+def christopher(user_input, language, show_history):
+    logger.info(f"Processing input: {user_input}, language: {language}, show_history: {show_history}")
     try:
-        # تولید کد
-        status_message, generated_code = generate_code(user_input, language)
-        
-        # دریافت تاریخچه در صورت درخواست
+        prompt, generated_code = generate_code(user_input, language)
         history = get_history() if show_history else ""
-        
-        logger.info("✅ Request processed successfully")
-        return generated_code, history, status_message
-        
+        return generated_code, history
     except Exception as e:
         logger.error(f"❌ Processing error: {e}")
-        error_response = f"# متأسفانه خطایی رخ داد: {str(e)}\nprint('لطفاً مجدداً تلاش کنید')"
         history = get_history() if show_history else ""
-        return error_response, history, f"❌ خطا: {str(e)}"
+        return f"خطا: {e}", 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("""
-        # 🤖 کریستوفر - دستیار هوشمند کدنویسی
-        ### 🚀 با قدرت مدل‌های OpenAI
-        
-        توضیح برنامه‌ای که می‌خواهید را به فارسی وارد کنید و زبان برنامه‌نویسی مورد نظر را انتخاب کنید.
-        """)
-        
-        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
+def gradio_ui(user_input, language, show_history):
+    code, history = christopher(user_input, language, show_history)
+    return code, history
 
-# تابع اصلی برنامه
-def main():
-    logger.info("🚀 Starting Christopher - Code Generation Assistant")
-    
+if __name__ == "__main__":
+    logger.info("Starting application")
     try:
-        # مقداردهی اولیه دیتابیس
         init_db()
-        
-        # ایجاد رابط گرادیو
-        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
+        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="توضیح برنامه را به فارسی وارد کنید و زبان برنامه‌نویسی را انتخاب کنید. برای نمایش تاریخچه، گزینه مربوطه را تیک بزنید."
         )
-        
+        iface.launch(server_name="0.0.0.0", server_port=7860)
     except Exception as e:
-        logger.error(f"❌ Application startup error: {e}")
-        raise
-
-if __name__ == "__main__":
-    main()
+        logger.error(f"❌ Startup error: {e}")
+        raise