Fix ChunkedIteratorResult in SQLAlchemyUserDatabase and toggleBtn null error

api/auth.py

@@ -60,7 +60,7 @@ github_oauth_client = GitHubOAuth2(GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET)
 
 class CustomSQLAlchemyUserDatabase(SQLAlchemyUserDatabase):
     async def get_by_email(self, email: str) -> Optional[User]:
-        """Override to fix ChunkedIteratorResult issue for get_by_email"""
+        """Override to fix ChunkedIteratorResult issue."""
         logger.info(f"Checking for user with email: {email}")
         try:
             statement = select(self.user_table).where(self.user_table.email == email)
@@ -76,7 +76,7 @@ class CustomSQLAlchemyUserDatabase(SQLAlchemyUserDatabase):
             raise
 
     async def create(self, create_dict: Dict[str, Any]) -> User:
-        """Override to fix potential async issues in create"""
+        """Override to fix potential async issues."""
         logger.info(f"Creating user with email: {create_dict.get('email')}")
         try:
             user = self.user_table(**create_dict)
@@ -95,7 +95,7 @@ class UserManager(IntegerIDMixin, BaseUserManager[User, int]):
     verification_token_secret = SECRET
 
     async def get_by_oauth_account(self, oauth_name: str, account_id: str):
-        """Override to fix ChunkedIteratorResult issue in SQLAlchemy 2.0+"""
+        """Override to fix ChunkedIteratorResult issue."""
         logger.info(f"Checking for existing OAuth account: {oauth_name}/{account_id}")
         try:
             statement = select(OAuthAccount).where(
@@ -113,7 +113,7 @@ class UserManager(IntegerIDMixin, BaseUserManager[User, int]):
             raise
 
     async def add_oauth_account(self, oauth_account: OAuthAccount):
-        """Override to fix potential async issues"""
+        """Override to fix potential async issues."""
         logger.info(f"Adding OAuth account for user {oauth_account.user_id}")
         try:
             self.session.add(oauth_account)

api/database.py

@@ -12,11 +12,11 @@ import logging
 logger = logging.getLogger(__name__)
 
 # جلب URL قاعدة البيانات من المتغيرات البيئية
-SQLALCHEMY_DATABASE_URL = os.getenv("SQLALCHEMY_DATABASE_URL")
+SQLALCHEMY_DATABASE_URL = os.getenv("SQLALCHEMY_DATABASE_URL", "sqlite+aiosqlite:///./data/mgzon_users.db")
 if not SQLALCHEMY_DATABASE_URL:
     raise ValueError("SQLALCHEMY_DATABASE_URL is not set in environment variables.")
 
-# إنشاء محرك async (استخدم sqlite+aiosqlite للدعم async)
+# إنشاء محرك async
 async_engine = create_async_engine(SQLALCHEMY_DATABASE_URL, echo=True)
 
 # إعداد جلسة async

api/endpoints.py

@@ -6,7 +6,8 @@ from api.database import User, Conversation, Message
 from api.models import QueryRequest, ConversationOut, ConversationCreate, UserUpdate
 from api.auth import current_active_user
 from api.database import get_db
-from sqlalchemy.orm import Session
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, delete
 from utils.generation import request_generation, select_model, check_model_availability
 from utils.web_search import web_search
 import io
@@ -145,7 +146,7 @@ async def chat_endpoint(
     request: Request,
     req: QueryRequest,
     user: User = Depends(current_active_user),
-    db: Session = Depends(get_db)
+    db: AsyncSession = Depends(get_db)
 ):
     logger.info(f"Received chat request: {req}")
     
@@ -155,7 +156,10 @@ async def chat_endpoint(
     conversation = None
     if user:
         title = req.title or (req.message[:50] + "..." if len(req.message) > 50 else req.message or "Untitled Conversation")
-        conversation = db.query(Conversation).filter(Conversation.user_id == user.id).order_by(Conversation.updated_at.desc()).first()
+        result = await db.execute(
+            select(Conversation).filter(Conversation.user_id == user.id).order_by(Conversation.updated_at.desc())
+        )
+        conversation = result.scalar_one_or_none()
         if not conversation:
             conversation_id = str(uuid.uuid4())
             conversation = Conversation(
@@ -164,12 +168,12 @@ async def chat_endpoint(
                 title=title
             )
             db.add(conversation)
-            db.commit()
-            db.refresh(conversation)
+            await db.commit()
+            await db.refresh(conversation)
         
         user_msg = Message(role="user", content=req.message, conversation_id=conversation.id)
         db.add(user_msg)
-        db.commit()
+        await db.commit()
     
     preferred_model = user.preferred_model if user else None
     model_name, api_endpoint = select_model(req.message, input_type="text", preferred_model=preferred_model)
@@ -231,9 +235,9 @@ async def chat_endpoint(
     if user and conversation:
         assistant_msg = Message(role="assistant", content=response, conversation_id=conversation.id)
         db.add(assistant_msg)
-        db.commit()
+        await db.commit()
         conversation.updated_at = datetime.utcnow()
-        db.commit()
+        await db.commit()
         return {
             "response": response,
             "conversation_id": conversation.conversation_id,
@@ -248,7 +252,7 @@ async def audio_transcription_endpoint(
     request: Request,
     file: UploadFile = File(...),
     user: User = Depends(current_active_user),
-    db: Session = Depends(get_db)
+    db: AsyncSession = Depends(get_db)
 ):
     logger.info(f"Received audio transcription request for file: {file.filename}")
     
@@ -258,7 +262,10 @@ async def audio_transcription_endpoint(
     conversation = None
     if user:
         title = "Audio Transcription"
-        conversation = db.query(Conversation).filter(Conversation.user_id == user.id).order_by(Conversation.updated_at.desc()).first()
+        result = await db.execute(
+            select(Conversation).filter(Conversation.user_id == user.id).order_by(Conversation.updated_at.desc())
+        )
+        conversation = result.scalar_one_or_none()
         if not conversation:
             conversation_id = str(uuid.uuid4())
             conversation = Conversation(
@@ -267,12 +274,12 @@ async def audio_transcription_endpoint(
                 title=title
             )
             db.add(conversation)
-            db.commit()
-            db.refresh(conversation)
+            await db.commit()
+            await db.refresh(conversation)
         
         user_msg = Message(role="user", content="Audio message", conversation_id=conversation.id)
         db.add(user_msg)
-        db.commit()
+        await db.commit()
     
     model_name, api_endpoint = select_model("transcribe audio", input_type="audio")
     
@@ -313,9 +320,9 @@ async def audio_transcription_endpoint(
     if user and conversation:
         assistant_msg = Message(role="assistant", content=response, conversation_id=conversation.id)
         db.add(assistant_msg)
-        db.commit()
+        await db.commit()
         conversation.updated_at = datetime.utcnow()
-        db.commit()
+        await db.commit()
         return {
             "transcription": response,
             "conversation_id": conversation.conversation_id,
@@ -330,7 +337,7 @@ async def text_to_speech_endpoint(
     request: Request,
     req: dict,
     user: User = Depends(current_active_user),
-    db: Session = Depends(get_db)
+    db: AsyncSession = Depends(get_db)
 ):
     if not user:
         await handle_session(request)
@@ -378,7 +385,7 @@ async def code_endpoint(
     request: Request,
     req: dict,
     user: User = Depends(current_active_user),
-    db: Session = Depends(get_db)
+    db: AsyncSession = Depends(get_db)
 ):
     if not user:
         await handle_session(request)
@@ -453,7 +460,7 @@ async def analysis_endpoint(
     request: Request,
     req: dict,
     user: User = Depends(current_active_user),
-    db: Session = Depends(get_db)
+    db: AsyncSession = Depends(get_db)
 ):
     if not user:
         await handle_session(request)
@@ -526,7 +533,7 @@ async def image_analysis_endpoint(
     file: UploadFile = File(...),
     output_format: str = "text",
     user: User = Depends(current_active_user),
-    db: Session = Depends(get_db)
+    db: AsyncSession = Depends(get_db)
 ):
     if not user:
         await handle_session(request)
@@ -534,7 +541,10 @@ async def image_analysis_endpoint(
     conversation = None
     if user:
         title = "Image Analysis"
-        conversation = db.query(Conversation).filter(Conversation.user_id == user.id).order_by(Conversation.updated_at.desc()).first()
+        result = await db.execute(
+            select(Conversation).filter(Conversation.user_id == user.id).order_by(Conversation.updated_at.desc())
+        )
+        conversation = result.scalar_one_or_none()
         if not conversation:
             conversation_id = str(uuid.uuid4())
             conversation = Conversation(
@@ -543,12 +553,12 @@ async def image_analysis_endpoint(
                 title=title
             )
             db.add(conversation)
-            db.commit()
-            db.refresh(conversation)
+            await db.commit()
+            await db.refresh(conversation)
         
         user_msg = Message(role="user", content="Image analysis request", conversation_id=conversation.id)
         db.add(user_msg)
-        db.commit()
+        await db.commit()
     
     preferred_model = user.preferred_model if user else None
     model_name, api_endpoint = select_model("analyze image", input_type="image", preferred_model=preferred_model)
@@ -608,9 +618,9 @@ async def image_analysis_endpoint(
         if user and conversation:
             assistant_msg = Message(role="assistant", content=response, conversation_id=conversation.id)
             db.add(assistant_msg)
-            db.commit()
+            await db.commit()
             conversation.updated_at = datetime.utcnow()
-            db.commit()
+            await db.commit()
             return {
                 "image_analysis": response,
                 "conversation_id": conversation.conversation_id,
@@ -646,7 +656,7 @@ async def test_model(model: str = MODEL_NAME, endpoint: str = API_ENDPOINT):
 async def create_conversation(
     req: ConversationCreate,
     user: User = Depends(current_active_user),
-    db: Session = Depends(get_db)
+    db: AsyncSession = Depends(get_db)
 ):
     if not user:
         raise HTTPException(status_code=401, detail="Login required")
@@ -657,77 +667,87 @@ async def create_conversation(
         user_id=user.id
     )
     db.add(conversation)
-    db.commit()
-    db.refresh(conversation)
+    await db.commit()
+    await db.refresh(conversation)
     return ConversationOut.from_orm(conversation)
 
 @router.get("/api/conversations/{conversation_id}", response_model=ConversationOut)
 async def get_conversation(
     conversation_id: str,
     user: User = Depends(current_active_user),
-    db: Session = Depends(get_db)
+    db: AsyncSession = Depends(get_db)
 ):
     if not user:
         raise HTTPException(status_code=401, detail="Login required")
-    conversation = db.query(Conversation).filter(
-        Conversation.conversation_id == conversation_id,
-        Conversation.user_id == user.id
-    ).first()
+    result = await db.execute(
+        select(Conversation).filter(
+            Conversation.conversation_id == conversation_id,
+            Conversation.user_id == user.id
+        )
+    )
+    conversation = result.scalar_one_or_none()
     if not conversation:
         raise HTTPException(status_code=404, detail="Conversation not found")
-    db.add(conversation)
-    db.commit()
     return ConversationOut.from_orm(conversation)
 
 @router.get("/api/conversations", response_model=List[ConversationOut])
 async def list_conversations(
     user: User = Depends(current_active_user),
-    db: Session = Depends(get_db)
+    db: AsyncSession = Depends(get_db)
 ):
     if not user:
         raise HTTPException(status_code=401, detail="Login required")
-    conversations = db.query(Conversation).filter(Conversation.user_id == user.id).order_by(Conversation.created_at.desc()).all()
-    return conversations
+    result = await db.execute(
+        select(Conversation).filter(Conversation.user_id == user.id).order_by(Conversation.created_at.desc())
+    )
+    conversations = result.scalars().all()
+    return [ConversationOut.from_orm(conv) for conv in conversations]
 
 @router.put("/api/conversations/{conversation_id}/title")
 async def update_conversation_title(
     conversation_id: str,
     title: str,
     user: User = Depends(current_active_user),
-    db: Session = Depends(get_db)
+    db: AsyncSession = Depends(get_db)
 ):
     if not user:
         raise HTTPException(status_code=401, detail="Login required")
-    conversation = db.query(Conversation).filter(
-        Conversation.conversation_id == conversation_id,
-        Conversation.user_id == user.id
-    ).first()
+    result = await db.execute(
+        select(Conversation).filter(
+            Conversation.conversation_id == conversation_id,
+            Conversation.user_id == user.id
+        )
+    )
+    conversation = result.scalar_one_or_none()
     if not conversation:
         raise HTTPException(status_code=404, detail="Conversation not found")
     
     conversation.title = title
     conversation.updated_at = datetime.utcnow()
-    db.commit()
+    await db.commit()
     return {"message": "Conversation title updated", "title": conversation.title}
 
 @router.delete("/api/conversations/{conversation_id}")
 async def delete_conversation(
     conversation_id: str,
     user: User = Depends(current_active_user),
-    db: Session = Depends(get_db)
+    db: AsyncSession = Depends(get_db)
 ):
     if not user:
         raise HTTPException(status_code=401, detail="Login required")
-    conversation = db.query(Conversation).filter(
-        Conversation.conversation_id == conversation_id,
-        Conversation.user_id == user.id
-    ).first()
+    result = await db.execute(
+        select(Conversation).filter(
+            Conversation.conversation_id == conversation_id,
+            Conversation.user_id == user.id
+        )
+    )
+    conversation = result.scalar_one_or_none()
     if not conversation:
         raise HTTPException(status_code=404, detail="Conversation not found")
     
-    db.query(Message).filter(Message.conversation_id == conversation.id).delete()
-    db.delete(conversation)
-    db.commit()
+    await db.execute(delete(Message).filter(Message.conversation_id == conversation.id))
+    await db.delete(conversation)
+    await db.commit()
     return {"message": "Conversation deleted successfully"}
 
 @router.get("/users/me")
@@ -752,7 +772,7 @@ async def get_user_settings(user: User = Depends(current_active_user)):
 async def update_user_settings(
     settings: UserUpdate,
     user: User = Depends(current_active_user),
-    db: Session = Depends(get_db)
+    db: AsyncSession = Depends(get_db)
 ):
     if not user:
         raise HTTPException(status_code=401, detail="Login required")
@@ -775,8 +795,8 @@ async def update_user_settings(
     if settings.conversation_style is not None:
         user.conversation_style = settings.conversation_style
     
-    db.commit()
-    db.refresh(user)
+    await db.commit()
+    await db.refresh(user)
     return {"message": "Settings updated successfully", "user": {
         "id": user.id,
         "email": user.email,
@@ -790,4 +810,3 @@ async def update_user_settings(
         "is_active": user.is_active,
         "is_superuser": user.is_superuser
     }}
-

api/models.py

@@ -34,7 +34,6 @@ class UserCreate(schemas.BaseUserCreate):
 
     model_config = {"from_attributes": True}
 
-# Pydantic schema for updating user settings
 class UserUpdate(BaseModel):
     display_name: Optional[str] = None
     preferred_model: Optional[str] = None

init_db.py

@@ -1,62 +1,68 @@
 import os
 import logging
+import asyncio
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, delete
 from api.database import async_engine, Base, User, OAuthAccount, Conversation, Message, AsyncSessionLocal
+from passlib.context import CryptContext
 
 # Setup logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-def init_db():
+# إعداد تشفير كلمة المرور
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+async def init_db():
     logger.info("Starting database initialization...")
 
-    # إنشاء الجداول (sync version for init_db.py)
+    # إنشاء الجداول
     try:
-        from sqlalchemy import create_engine
-        sync_engine = create_engine(os.getenv("SQLALCHEMY_DATABASE_URL", "sqlite:///./data/mgzon_users.db"))
-        Base.metadata.create_all(bind=sync_engine)
+        async with async_engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
         logger.info("Database tables created successfully.")
     except Exception as e:
         logger.error(f"Error creating database tables: {e}")
         raise
 
-    # تنظيف البيانات غير المتسقة (sync for simplicity in init_db)
-    try:
-        from sqlalchemy import select, delete
-        from sqlalchemy.orm import sessionmaker
-        sync_engine = create_engine(os.getenv("SQLALCHEMY_DATABASE_URL", "sqlite:///./data/mgzon_users.db"))
-        SyncSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=sync_engine)
-        with SyncSessionLocal() as session:
+    # تنظيف البيانات غير المتسقة
+    async with AsyncSessionLocal() as session:
+        try:
             # حذف سجلات oauth_accounts اللي مش مرتبطة بمستخدم موجود
             stmt = delete(OAuthAccount).where(
                 OAuthAccount.user_id.notin_(select(User.id))
             )
-            result = session.execute(stmt)
+            result = await session.execute(stmt)
             deleted_count = result.rowcount
-            session.commit()
+            await session.commit()
             logger.info(f"Deleted {deleted_count} orphaned OAuth accounts.")
 
             # التأكد من إن كل المستخدمين ليهم is_active=True
-            users = session.execute(select(User)).scalars().all()
+            users = (await session.execute(select(User))).scalars().all()
             for user in users:
                 if not user.is_active:
                     user.is_active = True
                     logger.info(f"Updated user {user.email} to is_active=True")
-            session.commit()
+            await session.commit()
 
             # اختبار إنشاء مستخدم ومحادثة (اختياري)
-            test_user = session.query(User).filter_by(email="test@example.com").first()
+            test_user = (await session.execute(
+                select(User).filter_by(email="test@example.com")
+            )).scalar_one_or_none()
             if not test_user:
                 test_user = User(
                     email="test@example.com",
-                    hashed_password="$2b$12$examplehashedpassword",  # استبدل بكلمة مرور مشفرة حقيقية
+                    hashed_password=pwd_context.hash("testpassword123"),  # تشفير كلمة المرور
                     is_active=True,
                     display_name="Test User"
                 )
                 session.add(test_user)
-                session.commit()
+                await session.commit()
                 logger.info("Test user created successfully.")
 
-            test_conversation = session.query(Conversation).filter_by(user_id=test_user.id).first()
+            test_conversation = (await session.execute(
+                select(Conversation).filter_by(user_id=test_user.id)
+            )).scalar_one_or_none()
             if not test_conversation:
                 test_conversation = Conversation(
                     conversation_id="test-conversation-1",
@@ -64,14 +70,17 @@ def init_db():
                     title="Test Conversation"
                 )
                 session.add(test_conversation)
-                session.commit()
+                await session.commit()
                 logger.info("Test conversation created successfully.")
 
-    except Exception as e:
-        logger.error(f"Error during initialization: {e}")
-        raise
+        except Exception as e:
+            await session.rollback()
+            logger.error(f"Error during initialization: {e}")
+            raise
+        finally:
+            await session.close()
 
     logger.info("Database initialization completed.")
 
 if __name__ == "__main__":
-    init_db()
+    asyncio.run(init_db())

requirements.txt

@@ -31,6 +31,8 @@ httpx-oauth==0.16.1
 python-multipart==0.0.17
 aiofiles==24.1.0
 motor==3.7.0
+aiosqlite==0.20.0  # إضافة لدعم SQLite async
+secrets==1.0.0  # للأمان في توليد كلمات سر عشوائية
 redis==5.0.0
 markdown2==2.5.0
 pymongo==4.10.1