feat(ui): AgentFactory-inspired dark theme redesign

Complete UI/UX overhaul with professional dark theme inspired by AgentFactory:

## Theme Changes (custom.css)
- Primary accent: Cyan/Teal (#00d4aa) for robotics feel
- Dark backgrounds: #0f0f14, #18181f (deep charcoal)
- Secondary accent: Electric Blue (#3b82f6)
- Professional typography with Inter font
- Smooth transitions and hover effects
- Custom scrollbar styling
- Print-friendly styles

## Homepage Redesign (index.js + index.module.css)
- Full-height hero section with gradient background
- Grid pattern overlay effect
- Animated humanoid robot with glowing cyan accents
- Professional badge/tag component
- Gradient text for title highlights
- New Stats section (8 Chapters, 16 Weeks, etc.)
- Redesigned highlight cards with hover animations
- Features grid with icons
- CTA section with radial gradient background

## Component Updates
- Reading Progress Bar: Cyan-to-blue gradient with glow
- Chapter Navigation: Glass-morphism dark cards
- Both components with light/dark mode support

## Design Elements
- Deep dark backgrounds (AgentFactory-style)
- Cyan/teal primary accents
- Subtle grid patterns
- Glassmorphism effects
- Smooth hover animations
- Professional typography
- Mobile-responsive design

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

alembic.ini

@@ -1,116 +1,116 @@
-# A generic, single database configuration.
-
-[alembic]
-# path to migration scripts
-script_location = database/migrations
-
-# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
-# Uncomment the line below if you want the files to be prepended with date and time
-# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
-# for all available tokens
-# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
-
-# sys.path path, will be prepended to sys.path if present.
-# defaults to the current working directory.
-prepend_sys_path = .
-
-# timezone to use when rendering the date within the migration file
-# as well as the filename.
-# If specified, requires the python>=3.9 or backports.zoneinfo library.
-# Any required deps can installed by adding `alembic[tz]` to the pip requirements
-# string value is passed to ZoneInfo()
-# leave blank for localtime
-# timezone =
-
-# max length of characters to apply to the
-# "slug" field
-# truncate_slug_length = 40
-
-# set to 'true' to run the environment during
-# the 'revision' command, regardless of autogenerate
-# revision_environment = false
-
-# set to 'true' to allow .pyc and .pyo files without
-# a source .py file to be detected as revisions in the
-# versions/ directory
-# sourceless = false
-
-# version location specification; This defaults
-# to database/migrations/versions.  When using multiple version
-# directories, initial revisions must be specified with --version-path.
-# The path separator used here should be the separator specified by "version_path_separator" below.
-# version_locations = %(here)s/bar:%(here)s/bat:database/migrations/versions
-
-# version path separator; As mentioned above, this is the character used to split
-# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
-# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
-# Valid values for version_path_separator are:
-#
-# version_path_separator = :
-# version_path_separator = ;
-# version_path_separator = space
-version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
-
-# set to 'true' to search source files recursively
-# in each "version_locations" directory
-# new in Alembic version 1.10
-# recursive_version_locations = false
-
-# the output encoding used when revision files
-# are written from script.py.mako
-# output_encoding = utf-8
-
-# sqlalchemy.url will be set in env.py from environment variable
-
-
-[post_write_hooks]
-# post_write_hooks defines scripts or Python functions that are run
-# on newly generated revision scripts.  See the documentation for further
-# detail and examples
-
-# format using "black" - use the console_scripts runner, against the "black" entrypoint
-# hooks = black
-# black.type = console_scripts
-# black.entrypoint = black
-# black.options = -l 79 REVISION_SCRIPT_FILENAME
-
-# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
-# hooks = ruff
-# ruff.type = exec
-# ruff.executable = %(here)s/.venv/bin/ruff
-# ruff.options = --fix REVISION_SCRIPT_FILENAME
-
-# Logging configuration
-[loggers]
-keys = root,sqlalchemy,alembic
-
-[handlers]
-keys = console
-
-[formatters]
-keys = generic
-
-[logger_root]
-level = WARN
-handlers = console
-qualname =
-
-[logger_sqlalchemy]
-level = WARN
-handlers =
-qualname = sqlalchemy.engine
-
-[logger_alembic]
-level = INFO
-handlers =
-qualname = alembic
-
-[handler_console]
-class = StreamHandler
-args = (sys.stderr,)
-level = NOTSET
-formatter = generic
-
-[formatter_generic]
-format = %(levelname)-5.5s [%(name)s] %(message)s
-datefmt = %H:%M:%S
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+script_location = database/migrations
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python>=3.9 or backports.zoneinfo library.
+# Any required deps can installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to ZoneInfo()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the
+# "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to database/migrations/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "version_path_separator" below.
+# version_locations = %(here)s/bar:%(here)s/bat:database/migrations/versions
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
+# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
+# Valid values for version_path_separator are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+# sqlalchemy.url will be set in env.py from environment variable
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = %(here)s/.venv/bin/ruff
+# ruff.options = --fix REVISION_SCRIPT_FILENAME
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

api/feedback.py

@@ -1,107 +1,107 @@
-"""
-Translation Feedback API
-
-Endpoint: POST /api/translate/feedback
-Purpose: Allow users to report translation quality issues
-"""
-
-from fastapi import APIRouter, Depends, HTTPException, Header
-from pydantic import BaseModel, Field
-from auth.jwt_utils import get_current_user_id_from_token
-from database.db import get_db
-from models.translation_feedback import TranslationFeedback
-from sqlalchemy import select
-from database.models import Translation
-import uuid
-import logging
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter()
-
-
-# JWT verification dependency
-def verify_jwt_token(authorization: str = Header(None)) -> dict:
-    """Verify JWT token from Authorization header"""
-    if not authorization:
-        raise HTTPException(status_code=401, detail="Authorization header missing")
-
-    if not authorization.startswith("Bearer "):
-        raise HTTPException(status_code=401, detail="Invalid authorization format")
-
-    token = authorization[7:]  # Remove "Bearer " prefix
-    user_id = get_current_user_id_from_token(token)
-
-    if not user_id:
-        raise HTTPException(status_code=401, detail="Invalid or expired token")
-
-    return {"user_id": user_id}
-
-
-class FeedbackRequest(BaseModel):
-    """Request model for submitting translation feedback"""
-    translation_id: str = Field(..., description="UUID of the translation being reported")
-    issue_description: str = Field(..., min_length=10, max_length=2000, description="Description of the translation issue")
-
-
-class FeedbackResponse(BaseModel):
-    """Response model for feedback submission"""
-    feedback_id: str
-    message: str
-
-
-@router.post("/api/translate/feedback", response_model=FeedbackResponse, status_code=201)
-def submit_translation_feedback(
-    request: FeedbackRequest,
-    user_data: dict = Depends(verify_jwt_token),
-    db = Depends(get_db)
-):
-    """
-    Submit feedback on translation quality
-
-    **Authentication**: JWT token required
-
-    **Request Body**:
-    - translation_id: UUID of the translation
-    - issue_description: Description of the issue (10-2000 characters)
-
-    **Response**: 201 Created with feedback_id
-    """
-    user_id = user_data["user_id"]
-
-    try:
-        # Validate translation_id is a valid UUID
-        translation_uuid = uuid.UUID(request.translation_id)
-    except ValueError:
-        raise HTTPException(status_code=400, detail="Invalid translation_id format. Must be a valid UUID.")
-
-    try:
-        # Optional: Verify translation exists (can skip for better performance)
-        # result = await db.execute(select(Translation).where(Translation.id == translation_uuid))
-        # translation = result.scalar_one_or_none()
-        # if not translation:
-        #     raise HTTPException(status_code=404, detail="Translation not found")
-
-        # Create feedback record
-        feedback = TranslationFeedback(
-            id=uuid.uuid4(),
-            translation_id=translation_uuid,
-            user_id=uuid.UUID(user_id),
-            issue_description=request.issue_description.strip()
-        )
-
-        db.add(feedback)
-        db.commit()
-        db.refresh(feedback)
-
-        logger.info(f"Feedback submitted: feedback_id={feedback.id}, translation_id={translation_uuid}, user_id={user_id}")
-
-        return FeedbackResponse(
-            feedback_id=str(feedback.id),
-            message="Thank you for your feedback! We'll review the translation quality issue."
-        )
-
-    except Exception as e:
-        logger.error(f"Failed to submit feedback: {str(e)}")
-        db.rollback()
-        raise HTTPException(status_code=500, detail=f"Failed to submit feedback: {str(e)}")
+"""
+Translation Feedback API
+
+Endpoint: POST /api/translate/feedback
+Purpose: Allow users to report translation quality issues
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, Header
+from pydantic import BaseModel, Field
+from auth.jwt_utils import get_current_user_id_from_token
+from database.db import get_db
+from models.translation_feedback import TranslationFeedback
+from sqlalchemy import select
+from database.models import Translation
+import uuid
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+# JWT verification dependency
+def verify_jwt_token(authorization: str = Header(None)) -> dict:
+    """Verify JWT token from Authorization header"""
+    if not authorization:
+        raise HTTPException(status_code=401, detail="Authorization header missing")
+
+    if not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="Invalid authorization format")
+
+    token = authorization[7:]  # Remove "Bearer " prefix
+    user_id = get_current_user_id_from_token(token)
+
+    if not user_id:
+        raise HTTPException(status_code=401, detail="Invalid or expired token")
+
+    return {"user_id": user_id}
+
+
+class FeedbackRequest(BaseModel):
+    """Request model for submitting translation feedback"""
+    translation_id: str = Field(..., description="UUID of the translation being reported")
+    issue_description: str = Field(..., min_length=10, max_length=2000, description="Description of the translation issue")
+
+
+class FeedbackResponse(BaseModel):
+    """Response model for feedback submission"""
+    feedback_id: str
+    message: str
+
+
+@router.post("/api/translate/feedback", response_model=FeedbackResponse, status_code=201)
+def submit_translation_feedback(
+    request: FeedbackRequest,
+    user_data: dict = Depends(verify_jwt_token),
+    db = Depends(get_db)
+):
+    """
+    Submit feedback on translation quality
+
+    **Authentication**: JWT token required
+
+    **Request Body**:
+    - translation_id: UUID of the translation
+    - issue_description: Description of the issue (10-2000 characters)
+
+    **Response**: 201 Created with feedback_id
+    """
+    user_id = user_data["user_id"]
+
+    try:
+        # Validate translation_id is a valid UUID
+        translation_uuid = uuid.UUID(request.translation_id)
+    except ValueError:
+        raise HTTPException(status_code=400, detail="Invalid translation_id format. Must be a valid UUID.")
+
+    try:
+        # Optional: Verify translation exists (can skip for better performance)
+        # result = await db.execute(select(Translation).where(Translation.id == translation_uuid))
+        # translation = result.scalar_one_or_none()
+        # if not translation:
+        #     raise HTTPException(status_code=404, detail="Translation not found")
+
+        # Create feedback record
+        feedback = TranslationFeedback(
+            id=uuid.uuid4(),
+            translation_id=translation_uuid,
+            user_id=uuid.UUID(user_id),
+            issue_description=request.issue_description.strip()
+        )
+
+        db.add(feedback)
+        db.commit()
+        db.refresh(feedback)
+
+        logger.info(f"Feedback submitted: feedback_id={feedback.id}, translation_id={translation_uuid}, user_id={user_id}")
+
+        return FeedbackResponse(
+            feedback_id=str(feedback.id),
+            message="Thank you for your feedback! We'll review the translation quality issue."
+        )
+
+    except Exception as e:
+        logger.error(f"Failed to submit feedback: {str(e)}")
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Failed to submit feedback: {str(e)}")

cleanup_code.py

@@ -1,149 +1,149 @@
-#!/usr/bin/env python3
-"""
-Code Cleanup Script for Feature 006: Urdu Translation
-
-Removes unused imports and organizes code
-Run: python3 cleanup_code.py
-"""
-
-import os
-import re
-from pathlib import Path
-
-
-def remove_unused_imports(file_path):
-    """Remove commented imports and organize imports"""
-    with open(file_path, 'r', encoding='utf-8') as f:
-        content = f.read()
-
-    original_content = content
-    lines = content.split('\n')
-    cleaned_lines = []
-    import_section = []
-    in_import_section = True
-
-    for line in lines:
-        # Skip empty lines in import section
-        if in_import_section and line.strip() == '':
-            continue
-
-        # Collect imports
-        if in_import_section and (line.startswith('import ') or line.startswith('from ')):
-            import_section.append(line)
-            continue
-
-        # End of import section
-        if in_import_section and not line.startswith('import ') and not line.startswith('from ') and line.strip():
-            in_import_section = False
-            # Add organized imports
-            import_section.sort()
-            cleaned_lines.extend(import_section)
-            cleaned_lines.append('')
-
-        cleaned_lines.append(line)
-
-    # Write back if changed
-    new_content = '\n'.join(cleaned_lines)
-    if new_content != original_content:
-        with open(file_path, 'w', encoding='utf-8') as f:
-            f.write(new_content)
-        return True
-    return False
-
-
-def cleanup_trailing_whitespace(file_path):
-    """Remove trailing whitespace from lines"""
-    with open(file_path, 'r', encoding='utf-8') as f:
-        content = f.read()
-
-    lines = content.split('\n')
-    cleaned_lines = [line.rstrip() for line in lines]
-    new_content = '\n'.join(cleaned_lines)
-
-    if new_content != content:
-        with open(file_path, 'w', encoding='utf-8') as f:
-            f.write(new_content)
-        return True
-    return False
-
-
-def check_pep8_line_length(file_path):
-    """Check for lines exceeding PEP 8 line length (120 chars is acceptable for modern code)"""
-    issues = []
-    with open(file_path, 'r', encoding='utf-8') as f:
-        for i, line in enumerate(f, 1):
-            if len(line.rstrip()) > 120:
-                issues.append(f"  Line {i}: {len(line.rstrip())} characters")
-
-    return issues
-
-
-def main():
-    """Main cleanup function"""
-    backend_dir = Path(__file__).parent
-
-    # Files to cleanup
-    files_to_check = [
-        'api/translation.py',
-        'api/feedback.py',
-        'services/translation_service.py',
-        'services/rate_limiter.py',
-        'models/translation_feedback.py',
-        'main.py'
-    ]
-
-    print("🧹 Starting code cleanup...")
-    print(f"📁 Backend directory: {backend_dir}\n")
-
-    total_files = 0
-    files_modified = 0
-
-    for file_rel_path in files_to_check:
-        file_path = backend_dir / file_rel_path
-
-        if not file_path.exists():
-            print(f"⚠️  {file_rel_path} - NOT FOUND")
-            continue
-
-        total_files += 1
-        print(f"🔍 Checking {file_rel_path}...")
-
-        modified = False
-
-        # Cleanup trailing whitespace
-        if cleanup_trailing_whitespace(file_path):
-            print(f"  ✅ Removed trailing whitespace")
-            modified = True
-
-        # Check line length
-        long_lines = check_pep8_line_length(file_path)
-        if long_lines:
-            print(f"  ⚠️  Found {len(long_lines)} lines exceeding 120 characters:")
-            for issue in long_lines[:3]:  # Show first 3
-                print(issue)
-            if len(long_lines) > 3:
-                print(f"  ... and {len(long_lines) - 3} more")
-
-        if modified:
-            files_modified += 1
-        else:
-            print(f"  ✓ No changes needed")
-
-        print()
-
-    print("═" * 50)
-    print(f"✅ Cleanup complete!")
-    print(f"📊 Files checked: {total_files}")
-    print(f"✏️  Files modified: {files_modified}")
-    print("═" * 50)
-
-    # Additional recommendations
-    print("\n📝 Additional Recommendations:")
-    print("  1. Run: pip install black flake8  # Install linters")
-    print("  2. Run: black backend/           # Auto-format code")
-    print("  3. Run: flake8 backend/          # Check PEP 8 compliance")
-    print("  4. Add .flake8 config to exclude tests/ from strict checks")
-
-
-if __name__ == '__main__':
-    main()
+#!/usr/bin/env python3
+"""
+Code Cleanup Script for Feature 006: Urdu Translation
+
+Removes unused imports and organizes code
+Run: python3 cleanup_code.py
+"""
+
+import os
+import re
+from pathlib import Path
+
+
+def remove_unused_imports(file_path):
+    """Remove commented imports and organize imports"""
+    with open(file_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    original_content = content
+    lines = content.split('\n')
+    cleaned_lines = []
+    import_section = []
+    in_import_section = True
+
+    for line in lines:
+        # Skip empty lines in import section
+        if in_import_section and line.strip() == '':
+            continue
+
+        # Collect imports
+        if in_import_section and (line.startswith('import ') or line.startswith('from ')):
+            import_section.append(line)
+            continue
+
+        # End of import section
+        if in_import_section and not line.startswith('import ') and not line.startswith('from ') and line.strip():
+            in_import_section = False
+            # Add organized imports
+            import_section.sort()
+            cleaned_lines.extend(import_section)
+            cleaned_lines.append('')
+
+        cleaned_lines.append(line)
+
+    # Write back if changed
+    new_content = '\n'.join(cleaned_lines)
+    if new_content != original_content:
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(new_content)
+        return True
+    return False
+
+
+def cleanup_trailing_whitespace(file_path):
+    """Remove trailing whitespace from lines"""
+    with open(file_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    lines = content.split('\n')
+    cleaned_lines = [line.rstrip() for line in lines]
+    new_content = '\n'.join(cleaned_lines)
+
+    if new_content != content:
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(new_content)
+        return True
+    return False
+
+
+def check_pep8_line_length(file_path):
+    """Check for lines exceeding PEP 8 line length (120 chars is acceptable for modern code)"""
+    issues = []
+    with open(file_path, 'r', encoding='utf-8') as f:
+        for i, line in enumerate(f, 1):
+            if len(line.rstrip()) > 120:
+                issues.append(f"  Line {i}: {len(line.rstrip())} characters")
+
+    return issues
+
+
+def main():
+    """Main cleanup function"""
+    backend_dir = Path(__file__).parent
+
+    # Files to cleanup
+    files_to_check = [
+        'api/translation.py',
+        'api/feedback.py',
+        'services/translation_service.py',
+        'services/rate_limiter.py',
+        'models/translation_feedback.py',
+        'main.py'
+    ]
+
+    print("🧹 Starting code cleanup...")
+    print(f"📁 Backend directory: {backend_dir}\n")
+
+    total_files = 0
+    files_modified = 0
+
+    for file_rel_path in files_to_check:
+        file_path = backend_dir / file_rel_path
+
+        if not file_path.exists():
+            print(f"⚠️  {file_rel_path} - NOT FOUND")
+            continue
+
+        total_files += 1
+        print(f"🔍 Checking {file_rel_path}...")
+
+        modified = False
+
+        # Cleanup trailing whitespace
+        if cleanup_trailing_whitespace(file_path):
+            print(f"  ✅ Removed trailing whitespace")
+            modified = True
+
+        # Check line length
+        long_lines = check_pep8_line_length(file_path)
+        if long_lines:
+            print(f"  ⚠️  Found {len(long_lines)} lines exceeding 120 characters:")
+            for issue in long_lines[:3]:  # Show first 3
+                print(issue)
+            if len(long_lines) > 3:
+                print(f"  ... and {len(long_lines) - 3} more")
+
+        if modified:
+            files_modified += 1
+        else:
+            print(f"  ✓ No changes needed")
+
+        print()
+
+    print("═" * 50)
+    print(f"✅ Cleanup complete!")
+    print(f"📊 Files checked: {total_files}")
+    print(f"✏️  Files modified: {files_modified}")
+    print("═" * 50)
+
+    # Additional recommendations
+    print("\n📝 Additional Recommendations:")
+    print("  1. Run: pip install black flake8  # Install linters")
+    print("  2. Run: black backend/           # Auto-format code")
+    print("  3. Run: flake8 backend/          # Check PEP 8 compliance")
+    print("  4. Add .flake8 config to exclude tests/ from strict checks")
+
+
+if __name__ == '__main__':
+    main()

database/migrations/env.py

@@ -1,92 +1,92 @@
-from logging.config import fileConfig
-import os
-import sys
-from pathlib import Path
-
-from sqlalchemy import engine_from_config
-from sqlalchemy import pool
-from dotenv import load_dotenv
-
-from alembic import context
-
-# Add parent directory to path to import models
-sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
-
-# Load environment variables
-load_dotenv()
-
-# this is the Alembic Config object, which provides
-# access to the values within the .ini file in use.
-config = context.config
-
-# Set sqlalchemy.url from environment variable
-config.set_main_option('sqlalchemy.url', os.getenv('NEON_POSTGRES_URL', ''))
-
-# Interpret the config file for Python logging.
-# This line sets up loggers basically.
-if config.config_file_name is not None:
-    fileConfig(config.config_file_name)
-
-# Import Base and models for autogenerate support
-from database.db import Base
-from database.models import User, Personalization, Translation  # Import all existing models
-from models.translation_feedback import TranslationFeedback  # Import TranslationFeedback model
-
-target_metadata = Base.metadata
-
-# other values from the config, defined by the needs of env.py,
-# can be acquired:
-# my_important_option = config.get_main_option("my_important_option")
-# ... etc.
-
-
-def run_migrations_offline() -> None:
-    """Run migrations in 'offline' mode.
-
-    This configures the context with just a URL
-    and not an Engine, though an Engine is acceptable
-    here as well.  By skipping the Engine creation
-    we don't even need a DBAPI to be available.
-
-    Calls to context.execute() here emit the given string to the
-    script output.
-
-    """
-    url = config.get_main_option("sqlalchemy.url")
-    context.configure(
-        url=url,
-        target_metadata=target_metadata,
-        literal_binds=True,
-        dialect_opts={"paramstyle": "named"},
-    )
-
-    with context.begin_transaction():
-        context.run_migrations()
-
-
-def run_migrations_online() -> None:
-    """Run migrations in 'online' mode.
-
-    In this scenario we need to create an Engine
-    and associate a connection with the context.
-
-    """
-    connectable = engine_from_config(
-        config.get_section(config.config_ini_section, {}),
-        prefix="sqlalchemy.",
-        poolclass=pool.NullPool,
-    )
-
-    with connectable.connect() as connection:
-        context.configure(
-            connection=connection, target_metadata=target_metadata
-        )
-
-        with context.begin_transaction():
-            context.run_migrations()
-
-
-if context.is_offline_mode():
-    run_migrations_offline()
-else:
-    run_migrations_online()
+from logging.config import fileConfig
+import os
+import sys
+from pathlib import Path
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+from dotenv import load_dotenv
+
+from alembic import context
+
+# Add parent directory to path to import models
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+
+# Load environment variables
+load_dotenv()
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Set sqlalchemy.url from environment variable
+config.set_main_option('sqlalchemy.url', os.getenv('NEON_POSTGRES_URL', ''))
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# Import Base and models for autogenerate support
+from database.db import Base
+from database.models import User, Personalization, Translation  # Import all existing models
+from models.translation_feedback import TranslationFeedback  # Import TranslationFeedback model
+
+target_metadata = Base.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

database/migrations/script.py.mako

@@ -1,26 +1,26 @@
-"""${message}
-
-Revision ID: ${up_revision}
-Revises: ${down_revision | comma,n}
-Create Date: ${create_date}
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-${imports if imports else ""}
-
-# revision identifiers, used by Alembic.
-revision: str = ${repr(up_revision)}
-down_revision: Union[str, None] = ${repr(down_revision)}
-branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
-depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
-
-
-def upgrade() -> None:
-    ${upgrades if upgrades else "pass"}
-
-
-def downgrade() -> None:
-    ${downgrades if downgrades else "pass"}
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}

database/migrations/versions/57c6b0ea13f8_add_translations_table.py

@@ -1,54 +1,54 @@
-"""add translations table
-
-Revision ID: 57c6b0ea13f8
-Revises: 
-Create Date: 2025-12-24 22:54:29.988202
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '57c6b0ea13f8'
-down_revision: Union[str, None] = None
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('translations',
-    sa.Column('id', sa.UUID(), nullable=False),
-    sa.Column('chapter_id', sa.String(length=255), nullable=False),
-    sa.Column('content_hash', sa.String(length=64), nullable=False),
-    sa.Column('source_language', sa.String(length=10), nullable=False),
-    sa.Column('target_language', sa.String(length=10), nullable=False),
-    sa.Column('original_content', sa.Text(), nullable=False),
-    sa.Column('translated_content', sa.Text(), nullable=False),
-    sa.Column('user_id', sa.UUID(), nullable=False),
-    sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=True),
-    sa.Column('updated_at', sa.DateTime(timezone=True), nullable=True),
-    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('chapter_id', 'content_hash', 'target_language', name='uq_chapter_hash_language')
-    )
-    op.create_index('idx_translations_lookup', 'translations', ['chapter_id', 'content_hash', 'target_language'], unique=False)
-    op.create_index(op.f('ix_translations_chapter_id'), 'translations', ['chapter_id'], unique=False)
-    op.create_index(op.f('ix_translations_content_hash'), 'translations', ['content_hash'], unique=False)
-    op.create_index(op.f('ix_translations_target_language'), 'translations', ['target_language'], unique=False)
-    op.create_index(op.f('ix_translations_user_id'), 'translations', ['user_id'], unique=False)
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_index(op.f('ix_translations_user_id'), table_name='translations')
-    op.drop_index(op.f('ix_translations_target_language'), table_name='translations')
-    op.drop_index(op.f('ix_translations_content_hash'), table_name='translations')
-    op.drop_index(op.f('ix_translations_chapter_id'), table_name='translations')
-    op.drop_index('idx_translations_lookup', table_name='translations')
-    op.drop_table('translations')
-    # ### end Alembic commands ###
+"""add translations table
+
+Revision ID: 57c6b0ea13f8
+Revises: 
+Create Date: 2025-12-24 22:54:29.988202
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '57c6b0ea13f8'
+down_revision: Union[str, None] = None
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('translations',
+    sa.Column('id', sa.UUID(), nullable=False),
+    sa.Column('chapter_id', sa.String(length=255), nullable=False),
+    sa.Column('content_hash', sa.String(length=64), nullable=False),
+    sa.Column('source_language', sa.String(length=10), nullable=False),
+    sa.Column('target_language', sa.String(length=10), nullable=False),
+    sa.Column('original_content', sa.Text(), nullable=False),
+    sa.Column('translated_content', sa.Text(), nullable=False),
+    sa.Column('user_id', sa.UUID(), nullable=False),
+    sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=True),
+    sa.Column('updated_at', sa.DateTime(timezone=True), nullable=True),
+    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
+    sa.PrimaryKeyConstraint('id'),
+    sa.UniqueConstraint('chapter_id', 'content_hash', 'target_language', name='uq_chapter_hash_language')
+    )
+    op.create_index('idx_translations_lookup', 'translations', ['chapter_id', 'content_hash', 'target_language'], unique=False)
+    op.create_index(op.f('ix_translations_chapter_id'), 'translations', ['chapter_id'], unique=False)
+    op.create_index(op.f('ix_translations_content_hash'), 'translations', ['content_hash'], unique=False)
+    op.create_index(op.f('ix_translations_target_language'), 'translations', ['target_language'], unique=False)
+    op.create_index(op.f('ix_translations_user_id'), 'translations', ['user_id'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_translations_user_id'), table_name='translations')
+    op.drop_index(op.f('ix_translations_target_language'), table_name='translations')
+    op.drop_index(op.f('ix_translations_content_hash'), table_name='translations')
+    op.drop_index(op.f('ix_translations_chapter_id'), table_name='translations')
+    op.drop_index('idx_translations_lookup', table_name='translations')
+    op.drop_table('translations')
+    # ### end Alembic commands ###

database/migrations/versions/809b34b1c5dc_add_translation_feedback_table.py

@@ -1,43 +1,43 @@
-"""add translation_feedback table
-
-Revision ID: 809b34b1c5dc
-Revises: 57c6b0ea13f8
-Create Date: 2025-12-25 01:42:15.691192
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '809b34b1c5dc'
-down_revision: Union[str, None] = '57c6b0ea13f8'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('translation_feedback',
-    sa.Column('id', sa.UUID(), nullable=False),
-    sa.Column('translation_id', sa.UUID(), nullable=False),
-    sa.Column('user_id', sa.UUID(), nullable=False),
-    sa.Column('issue_description', sa.Text(), nullable=False),
-    sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=True),
-    sa.ForeignKeyConstraint(['translation_id'], ['translations.id'], ondelete='CASCADE'),
-    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
-    sa.PrimaryKeyConstraint('id')
-    )
-    op.create_index(op.f('ix_translation_feedback_translation_id'), 'translation_feedback', ['translation_id'], unique=False)
-    op.create_index(op.f('ix_translation_feedback_user_id'), 'translation_feedback', ['user_id'], unique=False)
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_index(op.f('ix_translation_feedback_user_id'), table_name='translation_feedback')
-    op.drop_index(op.f('ix_translation_feedback_translation_id'), table_name='translation_feedback')
-    op.drop_table('translation_feedback')
-    # ### end Alembic commands ###
+"""add translation_feedback table
+
+Revision ID: 809b34b1c5dc
+Revises: 57c6b0ea13f8
+Create Date: 2025-12-25 01:42:15.691192
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '809b34b1c5dc'
+down_revision: Union[str, None] = '57c6b0ea13f8'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('translation_feedback',
+    sa.Column('id', sa.UUID(), nullable=False),
+    sa.Column('translation_id', sa.UUID(), nullable=False),
+    sa.Column('user_id', sa.UUID(), nullable=False),
+    sa.Column('issue_description', sa.Text(), nullable=False),
+    sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=True),
+    sa.ForeignKeyConstraint(['translation_id'], ['translations.id'], ondelete='CASCADE'),
+    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_translation_feedback_translation_id'), 'translation_feedback', ['translation_id'], unique=False)
+    op.create_index(op.f('ix_translation_feedback_user_id'), 'translation_feedback', ['user_id'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_translation_feedback_user_id'), table_name='translation_feedback')
+    op.drop_index(op.f('ix_translation_feedback_translation_id'), table_name='translation_feedback')
+    op.drop_table('translation_feedback')
+    # ### end Alembic commands ###

models/translation.py

@@ -1,34 +1,34 @@
-"""
-Translation model for storing Urdu translations with caching
-"""
-from sqlalchemy import Column, String, Text, DateTime, ForeignKey, UniqueConstraint, Index
-from sqlalchemy.dialects.postgresql import UUID
-from sqlalchemy.sql import func
-import uuid
-from database.db import Base
-
-
-class Translation(Base):
-    __tablename__ = "translations"
-
-    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    chapter_id = Column(String(255), nullable=False, index=True)
-    content_hash = Column(String(64), nullable=False, index=True)
-    source_language = Column(String(10), nullable=False, default="english")
-    target_language = Column(String(10), nullable=False, index=True)
-    original_content = Column(Text, nullable=False)
-    translated_content = Column(Text, nullable=False)
-    user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True)
-    created_at = Column(DateTime(timezone=True), server_default=func.now())
-    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
-
-    # Composite unique constraint: one translation per (chapter_id, content_hash, target_language)
-    # This ensures we don't duplicate translations when content is the same
-    __table_args__ = (
-        UniqueConstraint('chapter_id', 'content_hash', 'target_language', name='uq_chapter_hash_language'),
-        # Composite index for fast cache lookups
-        Index('idx_translations_lookup', 'chapter_id', 'content_hash', 'target_language'),
-    )
-
-    def __repr__(self):
-        return f"<Translation(chapter_id={self.chapter_id}, target_language={self.target_language}, cached=True)>"
+"""
+Translation model for storing Urdu translations with caching
+"""
+from sqlalchemy import Column, String, Text, DateTime, ForeignKey, UniqueConstraint, Index
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.sql import func
+import uuid
+from database.db import Base
+
+
+class Translation(Base):
+    __tablename__ = "translations"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    chapter_id = Column(String(255), nullable=False, index=True)
+    content_hash = Column(String(64), nullable=False, index=True)
+    source_language = Column(String(10), nullable=False, default="english")
+    target_language = Column(String(10), nullable=False, index=True)
+    original_content = Column(Text, nullable=False)
+    translated_content = Column(Text, nullable=False)
+    user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+
+    # Composite unique constraint: one translation per (chapter_id, content_hash, target_language)
+    # This ensures we don't duplicate translations when content is the same
+    __table_args__ = (
+        UniqueConstraint('chapter_id', 'content_hash', 'target_language', name='uq_chapter_hash_language'),
+        # Composite index for fast cache lookups
+        Index('idx_translations_lookup', 'chapter_id', 'content_hash', 'target_language'),
+    )
+
+    def __repr__(self):
+        return f"<Translation(chapter_id={self.chapter_id}, target_language={self.target_language}, cached=True)>"

models/translation_feedback.py

@@ -1,34 +1,34 @@
-"""
-TranslationFeedback Model
-
-Purpose: Store user feedback on translation quality for improvement
-"""
-
-from sqlalchemy import Column, String, Text, DateTime, ForeignKey
-from sqlalchemy.dialects.postgresql import UUID
-from sqlalchemy.sql import func
-import uuid
-from database.db import Base
-
-
-class TranslationFeedback(Base):
-    __tablename__ = "translation_feedback"
-
-    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    translation_id = Column(
-        UUID(as_uuid=True),
-        ForeignKey("translations.id", ondelete="CASCADE"),
-        nullable=False,
-        index=True
-    )
-    user_id = Column(
-        UUID(as_uuid=True),
-        ForeignKey("users.id", ondelete="CASCADE"),
-        nullable=False,
-        index=True
-    )
-    issue_description = Column(Text, nullable=False)
-    created_at = Column(DateTime(timezone=True), server_default=func.now())
-
-    def __repr__(self):
-        return f"<TranslationFeedback(translation_id={self.translation_id}, user_id={self.user_id}, issue='{self.issue_description[:50]}...')>"
+"""
+TranslationFeedback Model
+
+Purpose: Store user feedback on translation quality for improvement
+"""
+
+from sqlalchemy import Column, String, Text, DateTime, ForeignKey
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.sql import func
+import uuid
+from database.db import Base
+
+
+class TranslationFeedback(Base):
+    __tablename__ = "translation_feedback"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    translation_id = Column(
+        UUID(as_uuid=True),
+        ForeignKey("translations.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True
+    )
+    user_id = Column(
+        UUID(as_uuid=True),
+        ForeignKey("users.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True
+    )
+    issue_description = Column(Text, nullable=False)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    def __repr__(self):
+        return f"<TranslationFeedback(translation_id={self.translation_id}, user_id={self.user_id}, issue='{self.issue_description[:50]}...')>"

requirements.txt

@@ -1,18 +1,18 @@
-fastapi>=0.104.1
-uvicorn[standard]>=0.24.0
-sqlalchemy[asyncio]>=2.0.23
-asyncpg>=0.29.0
-qdrant-client>=1.7.1
-google-generativeai>=0.4.0
-python-multipart>=0.0.6
-python-jose[cryptography]>=3.3.0
-passlib[bcrypt]>=1.7.4
-better-exceptions>=0.3.3
-python-dotenv>=1.0.0
-pydantic>=2.5.0
-pydantic-settings>=2.1.0
-httpx>=0.25.2
-pytest>=7.4.3
-pytest-asyncio>=0.21.1
-alembic>=1.13.1
+fastapi>=0.104.1
+uvicorn[standard]>=0.24.0
+sqlalchemy[asyncio]>=2.0.23
+asyncpg>=0.29.0
+qdrant-client>=1.7.1
+google-generativeai>=0.4.0
+python-multipart>=0.0.6
+python-jose[cryptography]>=3.3.0
+passlib[bcrypt]>=1.7.4
+better-exceptions>=0.3.3
+python-dotenv>=1.0.0
+pydantic>=2.5.0
+pydantic-settings>=2.1.0
+httpx>=0.25.2
+pytest>=7.4.3
+pytest-asyncio>=0.21.1
+alembic>=1.13.1
 openai>=1.10.0

services/rate_limiter.py

@@ -1,115 +1,115 @@
-"""
-Rate limiter service for translation endpoints
-Implements in-memory sliding window algorithm (10 requests per user per hour)
-"""
-import time
-from collections import defaultdict
-from typing import Dict, List
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class RateLimiter:
-    """
-    In-memory rate limiter using sliding window algorithm
-
-    Limits: 10 translations per user per hour (3600 seconds)
-
-    Note: This is a simple in-memory implementation suitable for single-instance deployments.
-    For multi-instance/production deployments, consider using Redis for distributed rate limiting.
-    """
-
-    def __init__(self, max_requests: int = 10, window_seconds: int = 3600):
-        """
-        Initialize rate limiter
-
-        Args:
-            max_requests: Maximum number of requests allowed per window
-            window_seconds: Time window in seconds (default: 3600 = 1 hour)
-        """
-        self.max_requests = max_requests
-        self.window_seconds = window_seconds
-        # Store: {user_id: [timestamp1, timestamp2, ...]}
-        self.request_history: Dict[str, List[float]] = defaultdict(list)
-        logger.info(f"RateLimiter initialized: {max_requests} requests per {window_seconds}s")
-
-    def check_rate_limit(self, user_id: str) -> tuple[bool, int]:
-        """
-        Check if user has exceeded rate limit
-
-        Args:
-            user_id: User identifier (UUID string)
-
-        Returns:
-            tuple[bool, int]: (is_allowed, retry_after_seconds)
-            - is_allowed: True if request is allowed, False if rate limit exceeded
-            - retry_after_seconds: Seconds until rate limit resets (0 if allowed)
-        """
-        current_time = time.time()
-        cutoff_time = current_time - self.window_seconds
-
-        # Get user's request history
-        user_requests = self.request_history[user_id]
-
-        # Remove timestamps outside the sliding window
-        user_requests = [ts for ts in user_requests if ts > cutoff_time]
-        self.request_history[user_id] = user_requests
-
-        # Check if user has exceeded limit
-        if len(user_requests) >= self.max_requests:
-            # Calculate retry_after: time until oldest request expires
-            oldest_timestamp = user_requests[0]
-            retry_after = int(oldest_timestamp + self.window_seconds - current_time)
-
-            logger.warning(
-                f"Rate limit exceeded for user {user_id}: "
-                f"{len(user_requests)}/{self.max_requests} requests in last {self.window_seconds}s. "
-                f"Retry after {retry_after}s"
-            )
-            return False, retry_after
-
-        # Record this request
-        user_requests.append(current_time)
-        self.request_history[user_id] = user_requests
-
-        logger.debug(
-            f"Rate limit check passed for user {user_id}: "
-            f"{len(user_requests)}/{self.max_requests} requests in window"
-        )
-        return True, 0
-
-    def reset_user(self, user_id: str) -> None:
-        """
-        Reset rate limit for a specific user (admin function)
-
-        Args:
-            user_id: User identifier to reset
-        """
-        if user_id in self.request_history:
-            del self.request_history[user_id]
-            logger.info(f"Rate limit reset for user {user_id}")
-
-    def get_remaining_requests(self, user_id: str) -> int:
-        """
-        Get number of remaining requests for user in current window
-
-        Args:
-            user_id: User identifier
-
-        Returns:
-            int: Number of requests remaining
-        """
-        current_time = time.time()
-        cutoff_time = current_time - self.window_seconds
-
-        user_requests = self.request_history.get(user_id, [])
-        user_requests = [ts for ts in user_requests if ts > cutoff_time]
-
-        remaining = max(0, self.max_requests - len(user_requests))
-        return remaining
-
-
-# Global rate limiter instance (singleton)
-# 10 translations per user per hour
-translation_rate_limiter = RateLimiter(max_requests=10, window_seconds=3600)
+"""
+Rate limiter service for translation endpoints
+Implements in-memory sliding window algorithm (10 requests per user per hour)
+"""
+import time
+from collections import defaultdict
+from typing import Dict, List
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class RateLimiter:
+    """
+    In-memory rate limiter using sliding window algorithm
+
+    Limits: 10 translations per user per hour (3600 seconds)
+
+    Note: This is a simple in-memory implementation suitable for single-instance deployments.
+    For multi-instance/production deployments, consider using Redis for distributed rate limiting.
+    """
+
+    def __init__(self, max_requests: int = 10, window_seconds: int = 3600):
+        """
+        Initialize rate limiter
+
+        Args:
+            max_requests: Maximum number of requests allowed per window
+            window_seconds: Time window in seconds (default: 3600 = 1 hour)
+        """
+        self.max_requests = max_requests
+        self.window_seconds = window_seconds
+        # Store: {user_id: [timestamp1, timestamp2, ...]}
+        self.request_history: Dict[str, List[float]] = defaultdict(list)
+        logger.info(f"RateLimiter initialized: {max_requests} requests per {window_seconds}s")
+
+    def check_rate_limit(self, user_id: str) -> tuple[bool, int]:
+        """
+        Check if user has exceeded rate limit
+
+        Args:
+            user_id: User identifier (UUID string)
+
+        Returns:
+            tuple[bool, int]: (is_allowed, retry_after_seconds)
+            - is_allowed: True if request is allowed, False if rate limit exceeded
+            - retry_after_seconds: Seconds until rate limit resets (0 if allowed)
+        """
+        current_time = time.time()
+        cutoff_time = current_time - self.window_seconds
+
+        # Get user's request history
+        user_requests = self.request_history[user_id]
+
+        # Remove timestamps outside the sliding window
+        user_requests = [ts for ts in user_requests if ts > cutoff_time]
+        self.request_history[user_id] = user_requests
+
+        # Check if user has exceeded limit
+        if len(user_requests) >= self.max_requests:
+            # Calculate retry_after: time until oldest request expires
+            oldest_timestamp = user_requests[0]
+            retry_after = int(oldest_timestamp + self.window_seconds - current_time)
+
+            logger.warning(
+                f"Rate limit exceeded for user {user_id}: "
+                f"{len(user_requests)}/{self.max_requests} requests in last {self.window_seconds}s. "
+                f"Retry after {retry_after}s"
+            )
+            return False, retry_after
+
+        # Record this request
+        user_requests.append(current_time)
+        self.request_history[user_id] = user_requests
+
+        logger.debug(
+            f"Rate limit check passed for user {user_id}: "
+            f"{len(user_requests)}/{self.max_requests} requests in window"
+        )
+        return True, 0
+
+    def reset_user(self, user_id: str) -> None:
+        """
+        Reset rate limit for a specific user (admin function)
+
+        Args:
+            user_id: User identifier to reset
+        """
+        if user_id in self.request_history:
+            del self.request_history[user_id]
+            logger.info(f"Rate limit reset for user {user_id}")
+
+    def get_remaining_requests(self, user_id: str) -> int:
+        """
+        Get number of remaining requests for user in current window
+
+        Args:
+            user_id: User identifier
+
+        Returns:
+            int: Number of requests remaining
+        """
+        current_time = time.time()
+        cutoff_time = current_time - self.window_seconds
+
+        user_requests = self.request_history.get(user_id, [])
+        user_requests = [ts for ts in user_requests if ts > cutoff_time]
+
+        remaining = max(0, self.max_requests - len(user_requests))
+        return remaining
+
+
+# Global rate limiter instance (singleton)
+# 10 translations per user per hour
+translation_rate_limiter = RateLimiter(max_requests=10, window_seconds=3600)

services/translation_service.py

@@ -1,146 +1,146 @@
-from openai import OpenAI
-import logging
-from typing import Dict
-import time
-import os
-
-logger = logging.getLogger(__name__)
-
-class TranslationService:
-    def __init__(self, openrouter_api_key: str = None):
-        """Initialize OpenRouter client for translation using OpenAI SDK compatibility"""
-        api_key = openrouter_api_key or os.getenv("OPENROUTER_API_KEY")
-        self.client = OpenAI(
-            base_url="https://openrouter.ai/api/v1",
-            api_key=api_key
-        )
-        self.model = "google/gemini-2.0-flash-exp:free"
-        self.translation_cache: Dict[str, str] = {}
-        self.cache_timestamps: Dict[str, float] = {}
-
-    def translate_to_urdu(self, text: str, ttl: int = 3600) -> str:
-        """Translate English text to Urdu with caching"""
-        # Create cache key
-        cache_key = f"en_to_ur_{hash(text)}"
-
-        # Check if translation is in cache and not expired
-        if cache_key in self.translation_cache:
-            if time.time() - self.cache_timestamps.get(cache_key, 0) < ttl:
-                logger.info("Returning cached translation")
-                return self.translation_cache[cache_key]
-
-        # Call OpenRouter API for translation using OpenAI SDK
-        try:
-            system_prompt = self._get_urdu_translation_system_prompt()
-
-            response = self.client.chat.completions.create(
-                model=self.model,
-                messages=[
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": text}
-                ],
-                temperature=0.3,
-                max_tokens=8000
-            )
-
-            translated_text = response.choices[0].message.content.strip()
-
-            # Cache the translation
-            self.translation_cache[cache_key] = translated_text
-            self.cache_timestamps[cache_key] = time.time()
-
-            logger.info(f"Translated text to Urdu (length: {len(translated_text)} chars)")
-            return translated_text
-
-        except Exception as e:
-            logger.error(f"Translation failed: {str(e)}")
-            # Return a professional fallback response
-            return f"Translation unavailable: {text[:100]}..."
-
-    def _get_urdu_translation_system_prompt(self) -> str:
-        """Get the system prompt for Urdu translation from spec contract"""
-        return """You are a technical translator specializing in AI, robotics, and computer science education.
-Translate the following English text to Urdu following these rules strictly:
-
-TECHNICAL TERMS:
-- Keep in English: ROS2, Python, API, HTTP, JSON, ML, AI, function, class, variable, loop, array
-- Translate common words: robot → روبوٹ, computer → کمپیوٹر, network → نیٹ ورک
-- Transliterate ambiguous terms: Sensor → سینسر (Sensor), Actuator → ایکچویٹر (Actuator)
-- NEVER translate code identifiers (function names, variables, etc.)
-
-FORMATTING:
-- Preserve ALL markdown syntax (headings #, bold **, italic _, lists -, links [](url))
-- Keep code blocks entirely in English (including comments): ```language ... ```
-- Keep inline code in English: `variable_name`
-- Keep LaTeX math unchanged: $equation$
-- Translate link text but keep URLs: [ترجمہ شدہ متن](https://example.com)
-- Translate image alt text but keep src: ![روبوٹ کی تصویر](robot.png)
-
-TONE:
-- Use formal educational tone (not conversational)
-- Follow standard Urdu grammar rules
-- Use proper Urdu punctuation (،؟ instead of ,?)
-- Do not mix English and Urdu in same sentence except for technical terms listed above
-
-Translate now:"""
-
-    def translate_to_english(self, urdu_text: str, ttl: int = 3600) -> str:
-        """Translate Urdu text back to English with caching"""
-        # Create cache key
-        cache_key = f"ur_to_en_{hash(urdu_text)}"
-
-        # Check if translation is in cache and not expired
-        if cache_key in self.translation_cache:
-            if time.time() - self.cache_timestamps.get(cache_key, 0) < ttl:
-                logger.info("Returning cached translation")
-                return self.translation_cache[cache_key]
-
-        # Call OpenRouter API for translation using OpenAI SDK
-        try:
-            system_prompt = self._get_english_translation_system_prompt()
-
-            response = self.client.chat.completions.create(
-                model=self.model,
-                messages=[
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": urdu_text}
-                ],
-                temperature=0.3,
-                max_tokens=8000
-            )
-
-            translated_text = response.choices[0].message.content.strip()
-
-            # Cache the translation
-            self.translation_cache[cache_key] = translated_text
-            self.cache_timestamps[cache_key] = time.time()
-
-            logger.info(f"Translated text to English (length: {len(translated_text)} chars)")
-            return translated_text
-
-        except Exception as e:
-            logger.error(f"Translation failed: {str(e)}")
-            # Return a professional fallback response
-            return f"Translation unavailable: {urdu_text[:100]}..."
-
-    def _get_english_translation_system_prompt(self) -> str:
-        """Get the system prompt for English translation"""
-        return """You are a technical translator specializing in AI, robotics, and computer science education.
-Translate the following Urdu text to English with precision and accuracy.
-
-TRANSLATION REQUIREMENTS:
-- Maintain technical accuracy for robotics/AI terminology
-- Preserve the original meaning and context
-- Apply appropriate formality level for educational content
-- Ensure readability and flow in English
-- Keep technical terms (ROS2, Python, API, etc.) in English
-- Preserve markdown formatting and code blocks
-- Do not add any commentary or explanations
-
-Translate now:"""
-
-    def clear_cache(self):
-        """Clear the translation cache"""
-        self.translation_cache.clear()
-        self.cache_timestamps.clear()
+from openai import OpenAI
+import logging
+from typing import Dict
+import time
+import os
+
+logger = logging.getLogger(__name__)
+
+class TranslationService:
+    def __init__(self, openrouter_api_key: str = None):
+        """Initialize OpenRouter client for translation using OpenAI SDK compatibility"""
+        api_key = openrouter_api_key or os.getenv("OPENROUTER_API_KEY")
+        self.client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=api_key
+        )
+        self.model = "google/gemini-2.0-flash-exp:free"
+        self.translation_cache: Dict[str, str] = {}
+        self.cache_timestamps: Dict[str, float] = {}
+
+    def translate_to_urdu(self, text: str, ttl: int = 3600) -> str:
+        """Translate English text to Urdu with caching"""
+        # Create cache key
+        cache_key = f"en_to_ur_{hash(text)}"
+
+        # Check if translation is in cache and not expired
+        if cache_key in self.translation_cache:
+            if time.time() - self.cache_timestamps.get(cache_key, 0) < ttl:
+                logger.info("Returning cached translation")
+                return self.translation_cache[cache_key]
+
+        # Call OpenRouter API for translation using OpenAI SDK
+        try:
+            system_prompt = self._get_urdu_translation_system_prompt()
+
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": text}
+                ],
+                temperature=0.3,
+                max_tokens=8000
+            )
+
+            translated_text = response.choices[0].message.content.strip()
+
+            # Cache the translation
+            self.translation_cache[cache_key] = translated_text
+            self.cache_timestamps[cache_key] = time.time()
+
+            logger.info(f"Translated text to Urdu (length: {len(translated_text)} chars)")
+            return translated_text
+
+        except Exception as e:
+            logger.error(f"Translation failed: {str(e)}")
+            # Return a professional fallback response
+            return f"Translation unavailable: {text[:100]}..."
+
+    def _get_urdu_translation_system_prompt(self) -> str:
+        """Get the system prompt for Urdu translation from spec contract"""
+        return """You are a technical translator specializing in AI, robotics, and computer science education.
+Translate the following English text to Urdu following these rules strictly:
+
+TECHNICAL TERMS:
+- Keep in English: ROS2, Python, API, HTTP, JSON, ML, AI, function, class, variable, loop, array
+- Translate common words: robot → روبوٹ, computer → کمپیوٹر, network → نیٹ ورک
+- Transliterate ambiguous terms: Sensor → سینسر (Sensor), Actuator → ایکچویٹر (Actuator)
+- NEVER translate code identifiers (function names, variables, etc.)
+
+FORMATTING:
+- Preserve ALL markdown syntax (headings #, bold **, italic _, lists -, links [](url))
+- Keep code blocks entirely in English (including comments): ```language ... ```
+- Keep inline code in English: `variable_name`
+- Keep LaTeX math unchanged: $equation$
+- Translate link text but keep URLs: [ترجمہ شدہ متن](https://example.com)
+- Translate image alt text but keep src: ![روبوٹ کی تصویر](robot.png)
+
+TONE:
+- Use formal educational tone (not conversational)
+- Follow standard Urdu grammar rules
+- Use proper Urdu punctuation (،؟ instead of ,?)
+- Do not mix English and Urdu in same sentence except for technical terms listed above
+
+Translate now:"""
+
+    def translate_to_english(self, urdu_text: str, ttl: int = 3600) -> str:
+        """Translate Urdu text back to English with caching"""
+        # Create cache key
+        cache_key = f"ur_to_en_{hash(urdu_text)}"
+
+        # Check if translation is in cache and not expired
+        if cache_key in self.translation_cache:
+            if time.time() - self.cache_timestamps.get(cache_key, 0) < ttl:
+                logger.info("Returning cached translation")
+                return self.translation_cache[cache_key]
+
+        # Call OpenRouter API for translation using OpenAI SDK
+        try:
+            system_prompt = self._get_english_translation_system_prompt()
+
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": urdu_text}
+                ],
+                temperature=0.3,
+                max_tokens=8000
+            )
+
+            translated_text = response.choices[0].message.content.strip()
+
+            # Cache the translation
+            self.translation_cache[cache_key] = translated_text
+            self.cache_timestamps[cache_key] = time.time()
+
+            logger.info(f"Translated text to English (length: {len(translated_text)} chars)")
+            return translated_text
+
+        except Exception as e:
+            logger.error(f"Translation failed: {str(e)}")
+            # Return a professional fallback response
+            return f"Translation unavailable: {urdu_text[:100]}..."
+
+    def _get_english_translation_system_prompt(self) -> str:
+        """Get the system prompt for English translation"""
+        return """You are a technical translator specializing in AI, robotics, and computer science education.
+Translate the following Urdu text to English with precision and accuracy.
+
+TRANSLATION REQUIREMENTS:
+- Maintain technical accuracy for robotics/AI terminology
+- Preserve the original meaning and context
+- Apply appropriate formality level for educational content
+- Ensure readability and flow in English
+- Keep technical terms (ROS2, Python, API, etc.) in English
+- Preserve markdown formatting and code blocks
+- Do not add any commentary or explanations
+
+Translate now:"""
+
+    def clear_cache(self):
+        """Clear the translation cache"""
+        self.translation_cache.clear()
+        self.cache_timestamps.clear()
         logger.info("Translation cache cleared")

start.bat

@@ -1,26 +1,26 @@
-@echo off
-REM Batch script to start the backend server
-REM Usage: start.bat
-
-echo Starting AI Textbook Backend Server...
-
-REM Activate virtual environment
-if exist "venv\Scripts\activate.bat" (
-    echo Activating virtual environment...
-    call venv\Scripts\activate.bat
-) else (
-    echo Virtual environment not found. Creating one...
-    python -m venv venv
-    call venv\Scripts\activate.bat
-)
-
-REM Install dependencies
-echo Installing dependencies...
-pip install -r requirements.txt
-
-REM Start the server
-echo.
-echo Server starting on http://localhost:8001
-echo Press Ctrl+C to stop the server
-echo.
-python -m uvicorn main:app --host 0.0.0.0 --port 8001 --reload
+@echo off
+REM Batch script to start the backend server
+REM Usage: start.bat
+
+echo Starting AI Textbook Backend Server...
+
+REM Activate virtual environment
+if exist "venv\Scripts\activate.bat" (
+    echo Activating virtual environment...
+    call venv\Scripts\activate.bat
+) else (
+    echo Virtual environment not found. Creating one...
+    python -m venv venv
+    call venv\Scripts\activate.bat
+)
+
+REM Install dependencies
+echo Installing dependencies...
+pip install -r requirements.txt
+
+REM Start the server
+echo.
+echo Server starting on http://localhost:8001
+echo Press Ctrl+C to stop the server
+echo.
+python -m uvicorn main:app --host 0.0.0.0 --port 8001 --reload

start.ps1

@@ -1,23 +1,23 @@
-# PowerShell script to start the backend server
-# Usage: .\start.ps1
-
-Write-Host "🚀 Starting AI Textbook Backend Server..." -ForegroundColor Cyan
-
-# Check if virtual environment exists
-if (Test-Path ".\venv\Scripts\Activate.ps1") {
-    Write-Host "✓ Activating virtual environment..." -ForegroundColor Green
-    & .\venv\Scripts\Activate.ps1
-} else {
-    Write-Host "⚠ Virtual environment not found. Creating one..." -ForegroundColor Yellow
-    python -m venv venv
-    & .\venv\Scripts\Activate.ps1
-}
-
-# Install dependencies
-Write-Host "📦 Installing dependencies..." -ForegroundColor Cyan
-pip install -r requirements.txt
-
-# Start the server
-Write-Host "🌐 Starting server on http://localhost:8001" -ForegroundColor Green
-Write-Host "Press Ctrl+C to stop the server" -ForegroundColor Yellow
-python -m uvicorn main:app --host 0.0.0.0 --port 8001 --reload
+# PowerShell script to start the backend server
+# Usage: .\start.ps1
+
+Write-Host "🚀 Starting AI Textbook Backend Server..." -ForegroundColor Cyan
+
+# Check if virtual environment exists
+if (Test-Path ".\venv\Scripts\Activate.ps1") {
+    Write-Host "✓ Activating virtual environment..." -ForegroundColor Green
+    & .\venv\Scripts\Activate.ps1
+} else {
+    Write-Host "⚠ Virtual environment not found. Creating one..." -ForegroundColor Yellow
+    python -m venv venv
+    & .\venv\Scripts\Activate.ps1
+}
+
+# Install dependencies
+Write-Host "📦 Installing dependencies..." -ForegroundColor Cyan
+pip install -r requirements.txt
+
+# Start the server
+Write-Host "🌐 Starting server on http://localhost:8001" -ForegroundColor Green
+Write-Host "Press Ctrl+C to stop the server" -ForegroundColor Yellow
+python -m uvicorn main:app --host 0.0.0.0 --port 8001 --reload

test_formatted_message.py

@@ -1,61 +1,61 @@
-"""
-Test the formatted message parsing
-"""
-import os
-import sys
-from dotenv import load_dotenv
-
-load_dotenv()
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from services.rag_service import RAGService
-
-# Initialize
-api_key = os.getenv("OPENAI_API_KEY")
-rag_service = RAGService(api_key, None, "project_documents")
-
-# Test Case 1: User sends formatted message (what frontend sends)
-print("=== Test 1: Formatted Message (Current Issue) ===")
-selected_text = "Interactive Learning Features"
-question = """Selected text:
-"Interactive Learning Features"
-
-Ask a question about this text..."""
-
-print(f"Selected Text: {selected_text}")
-print(f"Question (formatted): {question}")
-
-# This is what's happening now - question should be extracted properly
-# In the fixed version, frontend will extract it, but let's test backend fallback
-answer = rag_service.query_rag(selected_text, question)
-print(f"\n✅ Answer: {answer[:200]}...")
-print(f"Length: {len(answer)} chars\n")
-
-# Test Case 2: User sends just the selected text (no question)
-print("=== Test 2: No Question, Just Selected Text ===")
-selected_text2 = "Physical AI refers to artificial intelligence"
-question2 = ""  # Empty question
-
-answer2 = rag_service.query_rag(selected_text2, question2)
-print(f"\n✅ Answer: {answer2[:200]}...")
-print(f"Length: {len(answer2)} chars\n")
-
-# Test Case 3: Normal question (should work)
-print("=== Test 3: Normal Question ===")
-selected_text3 = "Robots use sensors and actuators to interact with the environment"
-question3 = "What are sensors and actuators?"
-
-answer3 = rag_service.query_rag(selected_text3, question3)
-print(f"\n✅ Answer: {answer3[:200]}...")
-print(f"Length: {len(answer3)} chars\n")
-
-# Test Case 4: Question same as selected text
-print("=== Test 4: Question Same as Selected Text ===")
-selected_text4 = "Humanoid Robotics"
-question4 = "Humanoid Robotics"  # Same as selected text
-
-answer4 = rag_service.query_rag(selected_text4, question4)
-print(f"\n✅ Answer: {answer4[:200]}...")
-print(f"Length: {len(answer4)} chars\n")
-
-print("\n=== All Tests Complete ===")
+"""
+Test the formatted message parsing
+"""
+import os
+import sys
+from dotenv import load_dotenv
+
+load_dotenv()
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from services.rag_service import RAGService
+
+# Initialize
+api_key = os.getenv("OPENAI_API_KEY")
+rag_service = RAGService(api_key, None, "project_documents")
+
+# Test Case 1: User sends formatted message (what frontend sends)
+print("=== Test 1: Formatted Message (Current Issue) ===")
+selected_text = "Interactive Learning Features"
+question = """Selected text:
+"Interactive Learning Features"
+
+Ask a question about this text..."""
+
+print(f"Selected Text: {selected_text}")
+print(f"Question (formatted): {question}")
+
+# This is what's happening now - question should be extracted properly
+# In the fixed version, frontend will extract it, but let's test backend fallback
+answer = rag_service.query_rag(selected_text, question)
+print(f"\n✅ Answer: {answer[:200]}...")
+print(f"Length: {len(answer)} chars\n")
+
+# Test Case 2: User sends just the selected text (no question)
+print("=== Test 2: No Question, Just Selected Text ===")
+selected_text2 = "Physical AI refers to artificial intelligence"
+question2 = ""  # Empty question
+
+answer2 = rag_service.query_rag(selected_text2, question2)
+print(f"\n✅ Answer: {answer2[:200]}...")
+print(f"Length: {len(answer2)} chars\n")
+
+# Test Case 3: Normal question (should work)
+print("=== Test 3: Normal Question ===")
+selected_text3 = "Robots use sensors and actuators to interact with the environment"
+question3 = "What are sensors and actuators?"
+
+answer3 = rag_service.query_rag(selected_text3, question3)
+print(f"\n✅ Answer: {answer3[:200]}...")
+print(f"Length: {len(answer3)} chars\n")
+
+# Test Case 4: Question same as selected text
+print("=== Test 4: Question Same as Selected Text ===")
+selected_text4 = "Humanoid Robotics"
+question4 = "Humanoid Robotics"  # Same as selected text
+
+answer4 = rag_service.query_rag(selected_text4, question4)
+print(f"\n✅ Answer: {answer4[:200]}...")
+print(f"Length: {len(answer4)} chars\n")
+
+print("\n=== All Tests Complete ===")

test_openrouter_direct.py

@@ -1,79 +1,79 @@
-"""
-Direct test of OpenRouter API to verify it's working
-"""
-import os
-from dotenv import load_dotenv
-from openai import OpenAI
-
-# Load environment variables
-load_dotenv()
-
-api_key = os.getenv("OPENAI_API_KEY")
-print(f"API Key loaded: {api_key[:20]}..." if api_key else "No API key found!")
-
-# Initialize OpenAI client with OpenRouter
-client = OpenAI(
-    api_key=api_key,
-    base_url="https://openrouter.ai/api/v1"
-)
-
-# Test 1: Simple chat completion
-print("\n=== Test 1: Simple Chat ===")
-try:
-    response = client.chat.completions.create(
-        model="openai/gpt-3.5-turbo",
-        messages=[
-            {"role": "user", "content": "Say 'Hello, I am working!' in one sentence."}
-        ],
-        temperature=0
-    )
-    print(f"✅ Success: {response.choices[0].message.content}")
-except Exception as e:
-    print(f"❌ Error: {str(e)}")
-
-# Test 2: RAG-style query with context
-print("\n=== Test 2: RAG with Context ===")
-context = """
-Physical AI refers to artificial intelligence systems that interact with the physical world.
-These systems use sensors to perceive their environment and actuators to take actions.
-Examples include robots, self-driving cars, and drones.
-"""
-
-question = "What is Physical AI?"
-
-try:
-    response = client.chat.completions.create(
-        model="openai/gpt-3.5-turbo",
-        messages=[
-            {"role": "system", "content": "You are a helpful AI assistant. Answer based on the provided context."},
-            {"role": "user", "content": f"Context: {context}\n\nQuestion: {question}"}
-        ],
-        temperature=0.3,
-        max_tokens=500
-    )
-    print(f"✅ Success: {response.choices[0].message.content}")
-except Exception as e:
-    print(f"❌ Error: {str(e)}")
-
-# Test 3: Check if response is empty or too short
-print("\n=== Test 3: Response Length Check ===")
-try:
-    response = client.chat.completions.create(
-        model="openai/gpt-3.5-turbo",
-        messages=[
-            {"role": "user", "content": "Explain robotics in 50 words."}
-        ],
-        temperature=0.3
-    )
-    answer = response.choices[0].message.content
-    print(f"Response length: {len(answer)} characters")
-    print(f"Response: {answer}")
-
-    if len(answer) < 20:
-        print("⚠️ WARNING: Response too short!")
-    else:
-        print("✅ Response length is good")
-except Exception as e:
-    print(f"❌ Error: {str(e)}")
-
-print("\n=== All Tests Complete ===")
+"""
+Direct test of OpenRouter API to verify it's working
+"""
+import os
+from dotenv import load_dotenv
+from openai import OpenAI
+
+# Load environment variables
+load_dotenv()
+
+api_key = os.getenv("OPENAI_API_KEY")
+print(f"API Key loaded: {api_key[:20]}..." if api_key else "No API key found!")
+
+# Initialize OpenAI client with OpenRouter
+client = OpenAI(
+    api_key=api_key,
+    base_url="https://openrouter.ai/api/v1"
+)
+
+# Test 1: Simple chat completion
+print("\n=== Test 1: Simple Chat ===")
+try:
+    response = client.chat.completions.create(
+        model="openai/gpt-3.5-turbo",
+        messages=[
+            {"role": "user", "content": "Say 'Hello, I am working!' in one sentence."}
+        ],
+        temperature=0
+    )
+    print(f"✅ Success: {response.choices[0].message.content}")
+except Exception as e:
+    print(f"❌ Error: {str(e)}")
+
+# Test 2: RAG-style query with context
+print("\n=== Test 2: RAG with Context ===")
+context = """
+Physical AI refers to artificial intelligence systems that interact with the physical world.
+These systems use sensors to perceive their environment and actuators to take actions.
+Examples include robots, self-driving cars, and drones.
+"""
+
+question = "What is Physical AI?"
+
+try:
+    response = client.chat.completions.create(
+        model="openai/gpt-3.5-turbo",
+        messages=[
+            {"role": "system", "content": "You are a helpful AI assistant. Answer based on the provided context."},
+            {"role": "user", "content": f"Context: {context}\n\nQuestion: {question}"}
+        ],
+        temperature=0.3,
+        max_tokens=500
+    )
+    print(f"✅ Success: {response.choices[0].message.content}")
+except Exception as e:
+    print(f"❌ Error: {str(e)}")
+
+# Test 3: Check if response is empty or too short
+print("\n=== Test 3: Response Length Check ===")
+try:
+    response = client.chat.completions.create(
+        model="openai/gpt-3.5-turbo",
+        messages=[
+            {"role": "user", "content": "Explain robotics in 50 words."}
+        ],
+        temperature=0.3
+    )
+    answer = response.choices[0].message.content
+    print(f"Response length: {len(answer)} characters")
+    print(f"Response: {answer}")
+
+    if len(answer) < 20:
+        print("⚠️ WARNING: Response too short!")
+    else:
+        print("✅ Response length is good")
+except Exception as e:
+    print(f"❌ Error: {str(e)}")
+
+print("\n=== All Tests Complete ===")

test_rag_service_debug.py

@@ -1,73 +1,73 @@
-"""
-Debug the RAG service to see what's happening
-"""
-import os
-import sys
-import logging
-from dotenv import load_dotenv
-from qdrant_client import QdrantClient
-
-# Setup logging
-logging.basicConfig(level=logging.DEBUG)
-
-# Load environment
-load_dotenv()
-
-# Import RAG service
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from services.rag_service import RAGService
-
-# Initialize
-api_key = os.getenv("OPENAI_API_KEY")
-qdrant_url = os.getenv("QDRANT_URL")
-qdrant_api_key = os.getenv("QDRANT_API_KEY")
-collection_name = os.getenv("QDRANT_COLLECTION", "project_documents")
-
-print(f"API Key: {api_key[:20]}..." if api_key else "No API key")
-print(f"Qdrant URL: {qdrant_url}")
-print(f"Collection: {collection_name}")
-
-# Initialize Qdrant client
-qdrant_host = os.getenv("QDRANT_HOST")
-if qdrant_api_key and qdrant_host and "qdrant.io" in qdrant_host:
-    print("\n✅ Using Qdrant Cloud")
-    qdrant_client = QdrantClient(
-        url=qdrant_host,
-        api_key=qdrant_api_key,
-        prefer_grpc=False
-    )
-else:
-    print("\n✅ Using Local Qdrant (without Qdrant for testing)")
-    # Don't initialize Qdrant for now - test without it
-    qdrant_client = None
-    print("⚠️ Qdrant disabled for testing - will use selected text only")
-
-# Initialize RAG service
-rag_service = RAGService(api_key, qdrant_client, collection_name)
-
-# Test query
-selected_text = """
-Physical AI refers to artificial intelligence systems that interact with the physical world.
-These systems use sensors to perceive their environment and actuators to take actions.
-Examples include robots, self-driving cars, and drones.
-"""
-
-question = "What is Physical AI?"
-
-print("\n=== Testing RAG Service ===")
-print(f"Selected Text Length: {len(selected_text)} chars")
-print(f"Question: {question}")
-
-try:
-    answer = rag_service.query_rag(selected_text, question)
-    print(f"\n✅ Answer received:")
-    print(f"Length: {len(answer)} chars")
-    print(f"Content: {answer}")
-
-    if "Is sawal ka jawab provided data me mojood nahi hai" in answer:
-        print("\n❌ ERROR: Getting fallback message!")
-        print("This means the RAG logic is failing somewhere.")
-except Exception as e:
-    print(f"\n❌ Error: {str(e)}")
-    import traceback
-    traceback.print_exc()
+"""
+Debug the RAG service to see what's happening
+"""
+import os
+import sys
+import logging
+from dotenv import load_dotenv
+from qdrant_client import QdrantClient
+
+# Setup logging
+logging.basicConfig(level=logging.DEBUG)
+
+# Load environment
+load_dotenv()
+
+# Import RAG service
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from services.rag_service import RAGService
+
+# Initialize
+api_key = os.getenv("OPENAI_API_KEY")
+qdrant_url = os.getenv("QDRANT_URL")
+qdrant_api_key = os.getenv("QDRANT_API_KEY")
+collection_name = os.getenv("QDRANT_COLLECTION", "project_documents")
+
+print(f"API Key: {api_key[:20]}..." if api_key else "No API key")
+print(f"Qdrant URL: {qdrant_url}")
+print(f"Collection: {collection_name}")
+
+# Initialize Qdrant client
+qdrant_host = os.getenv("QDRANT_HOST")
+if qdrant_api_key and qdrant_host and "qdrant.io" in qdrant_host:
+    print("\n✅ Using Qdrant Cloud")
+    qdrant_client = QdrantClient(
+        url=qdrant_host,
+        api_key=qdrant_api_key,
+        prefer_grpc=False
+    )
+else:
+    print("\n✅ Using Local Qdrant (without Qdrant for testing)")
+    # Don't initialize Qdrant for now - test without it
+    qdrant_client = None
+    print("⚠️ Qdrant disabled for testing - will use selected text only")
+
+# Initialize RAG service
+rag_service = RAGService(api_key, qdrant_client, collection_name)
+
+# Test query
+selected_text = """
+Physical AI refers to artificial intelligence systems that interact with the physical world.
+These systems use sensors to perceive their environment and actuators to take actions.
+Examples include robots, self-driving cars, and drones.
+"""
+
+question = "What is Physical AI?"
+
+print("\n=== Testing RAG Service ===")
+print(f"Selected Text Length: {len(selected_text)} chars")
+print(f"Question: {question}")
+
+try:
+    answer = rag_service.query_rag(selected_text, question)
+    print(f"\n✅ Answer received:")
+    print(f"Length: {len(answer)} chars")
+    print(f"Content: {answer}")
+
+    if "Is sawal ka jawab provided data me mojood nahi hai" in answer:
+        print("\n❌ ERROR: Getting fallback message!")
+        print("This means the RAG logic is failing somewhere.")
+except Exception as e:
+    print(f"\n❌ Error: {str(e)}")
+    import traceback
+    traceback.print_exc()

tests/e2e/test_translation_flow.py

@@ -1,295 +1,295 @@
-"""
-End-to-End Test: Complete Translation Flow
-
-Tests the full user journey:
-1. User signup
-2. Login
-3. Navigate to chapter
-4. Translate to Urdu
-5. Toggle back to English
-6. Submit feedback
-
-Note: Requires Playwright installation:
-    pip install playwright pytest-playwright
-    playwright install
-"""
-
-import pytest
-from playwright.sync_api import Page, expect
-import time
-
-
-# Test configuration
-BASE_URL = "http://localhost:3000"
-API_URL = "http://localhost:8001"
-TEST_USER_EMAIL = f"test_{int(time.time())}@example.com"
-TEST_USER_PASSWORD = "Test1234!"
-
-
-@pytest.fixture(scope="module")
-def browser_context(playwright):
-    """Create browser context for all tests"""
-    browser = playwright.chromium.launch(headless=True)
-    context = browser.new_context(viewport={"width": 1920, "height": 1080})
-    yield context
-    context.close()
-    browser.close()
-
-
-@pytest.fixture
-def page(browser_context):
-    """Create new page for each test"""
-    page = browser_context.new_page()
-    yield page
-    page.close()
-
-
-class TestTranslationE2E:
-    """End-to-end translation flow tests"""
-
-    def test_01_user_signup(self, page: Page):
-        """Test 1: User can sign up with software/hardware background"""
-        print(f"\n🧪 Test 1: Signup with email: {TEST_USER_EMAIL}")
-
-        # Navigate to signup page
-        page.goto(f"{BASE_URL}/signup")
-        page.wait_for_load_state("networkidle")
-
-        # Fill signup form
-        page.fill('input[type="email"]', TEST_USER_EMAIL)
-        page.fill('input[type="password"]', TEST_USER_PASSWORD)
-        page.fill('textarea[placeholder*="software"]', "Python, JavaScript, ROS2")
-        page.fill('textarea[placeholder*="hardware"]', "Arduino, Raspberry Pi")
-
-        # Submit form
-        page.click('button[type="submit"]')
-        page.wait_for_timeout(2000)
-
-        # Verify redirect to homepage or dashboard
-        assert "signup" not in page.url.lower() or "login" in page.url.lower()
-        print("✅ Signup successful")
-
-    def test_02_user_login(self, page: Page):
-        """Test 2: User can login with credentials"""
-        print(f"\n🧪 Test 2: Login with email: {TEST_USER_EMAIL}")
-
-        # Navigate to login page
-        page.goto(f"{BASE_URL}/login")
-        page.wait_for_load_state("networkidle")
-
-        # Fill login form
-        page.fill('input[type="email"]', TEST_USER_EMAIL)
-        page.fill('input[type="password"]', TEST_USER_PASSWORD)
-
-        # Submit form
-        page.click('button[type="submit"]')
-        page.wait_for_timeout(2000)
-
-        # Verify authentication (should see logout or profile)
-        assert "login" not in page.url.lower()
-        print("✅ Login successful")
-
-    def test_03_navigate_to_chapter(self, page: Page):
-        """Test 3: User can navigate to a chapter with translation support"""
-        print("\n🧪 Test 3: Navigate to ROS2 Fundamentals chapter")
-
-        # Login first
-        page.goto(f"{BASE_URL}/login")
-        page.fill('input[type="email"]', TEST_USER_EMAIL)
-        page.fill('input[type="password"]', TEST_USER_PASSWORD)
-        page.click('button[type="submit"]')
-        page.wait_for_timeout(2000)
-
-        # Navigate to chapter with translation support
-        page.goto(f"{BASE_URL}/docs/ros2-fundamentals")
-        page.wait_for_load_state("networkidle")
-
-        # Verify chapter loaded
-        assert "ros2" in page.url.lower() or "fundamentals" in page.url.lower()
-
-        # Verify translation button exists
-        translate_button = page.locator('button:has-text("Translate to Urdu")')
-        expect(translate_button).to_be_visible(timeout=5000)
-        print("✅ Chapter loaded with translation button")
-
-    def test_04_translate_to_urdu(self, page: Page):
-        """Test 4: User can translate chapter to Urdu (first time - API call)"""
-        print("\n🧪 Test 4: Translate chapter to Urdu")
-
-        # Login and navigate to chapter
-        page.goto(f"{BASE_URL}/login")
-        page.fill('input[type="email"]', TEST_USER_EMAIL)
-        page.fill('input[type="password"]', TEST_USER_PASSWORD)
-        page.click('button[type="submit"]')
-        page.wait_for_timeout(2000)
-
-        page.goto(f"{BASE_URL}/docs/intro")
-        page.wait_for_load_state("networkidle")
-
-        # Click translate button
-        translate_button = page.locator('button:has-text("Translate to Urdu")')
-        translate_button.click()
-
-        # Verify loading state appears
-        loading_indicator = page.locator('text=Translating')
-        expect(loading_indicator).to_be_visible(timeout=2000)
-        print("⏳ Loading indicator visible")
-
-        # Wait for translation to complete (8-10 seconds)
-        page.wait_for_timeout(12000)
-
-        # Verify button changed to "View in English"
-        english_button = page.locator('button:has-text("View in English")')
-        expect(english_button).to_be_visible(timeout=15000)
-        print("✅ Translation completed successfully")
-
-        # Verify Urdu content is displayed (check for RTL)
-        # Note: Actual Urdu verification would need OCR or specific text matching
-        page.wait_for_timeout(1000)
-
-    def test_05_toggle_to_english(self, page: Page):
-        """Test 5: User can toggle back to English instantly"""
-        print("\n🧪 Test 5: Toggle back to English")
-
-        # Login, navigate, and translate first
-        page.goto(f"{BASE_URL}/login")
-        page.fill('input[type="email"]', TEST_USER_EMAIL)
-        page.fill('input[type="password"]', TEST_USER_PASSWORD)
-        page.click('button[type="submit"]')
-        page.wait_for_timeout(2000)
-
-        page.goto(f"{BASE_URL}/docs/intro")
-        page.wait_for_load_state("networkidle")
-
-        # Translate to Urdu first
-        translate_button = page.locator('button:has-text("Translate to Urdu")')
-        if translate_button.is_visible():
-            translate_button.click()
-            page.wait_for_timeout(12000)
-
-        # Click "View in English" button
-        english_button = page.locator('button:has-text("View in English")')
-        start_time = time.time()
-        english_button.click()
-
-        # Verify instant toggle (<100ms target, but allow 1s for UI)
-        page.wait_for_timeout(500)
-        urdu_button = page.locator('button:has-text("Translate to Urdu")')
-        expect(urdu_button).to_be_visible(timeout=2000)
-
-        elapsed = time.time() - start_time
-        print(f"✅ Toggled to English in {elapsed:.2f}s (instant)")
-        assert elapsed < 2.0, "Toggle should be instant (<2s)"
-
-    def test_06_cached_translation(self, page: Page):
-        """Test 6: Second translation loads from cache (<1s)"""
-        print("\n🧪 Test 6: Cached translation loading")
-
-        # Login and navigate
-        page.goto(f"{BASE_URL}/login")
-        page.fill('input[type="email"]', TEST_USER_EMAIL)
-        page.fill('input[type="password"]', TEST_USER_PASSWORD)
-        page.click('button[type="submit"]')
-        page.wait_for_timeout(2000)
-
-        page.goto(f"{BASE_URL}/docs/intro")
-        page.wait_for_load_state("networkidle")
-
-        # Ensure we're in English view
-        english_button = page.locator('button:has-text("View in English")')
-        if english_button.is_visible():
-            english_button.click()
-            page.wait_for_timeout(500)
-
-        # Click translate again (should hit cache)
-        translate_button = page.locator('button:has-text("Translate to Urdu")')
-        start_time = time.time()
-        translate_button.click()
-
-        # Wait for translation to complete
-        english_button = page.locator('button:has-text("View in English")')
-        expect(english_button).to_be_visible(timeout=5000)
-
-        elapsed = time.time() - start_time
-        print(f"✅ Cache hit in {elapsed:.2f}s")
-
-        # Verify cache indicator visible
-        cache_indicator = page.locator('text=Loaded from cache')
-        # Cache indicator might not always be visible, so don't assert
-        if cache_indicator.is_visible(timeout=1000):
-            print("⚡ Cache indicator displayed")
-
-    def test_07_submit_feedback(self, page: Page):
-        """Test 7: User can submit translation feedback"""
-        print("\n🧪 Test 7: Submit translation feedback")
-
-        # Login, navigate, and translate
-        page.goto(f"{BASE_URL}/login")
-        page.fill('input[type="email"]', TEST_USER_EMAIL)
-        page.fill('input[type="password"]', TEST_USER_PASSWORD)
-        page.click('button[type="submit"]')
-        page.wait_for_timeout(2000)
-
-        page.goto(f"{BASE_URL}/docs/intro")
-        page.wait_for_load_state("networkidle")
-
-        # Translate to Urdu first
-        translate_button = page.locator('button:has-text("Translate to Urdu")')
-        if translate_button.is_visible():
-            translate_button.click()
-            page.wait_for_timeout(12000)
-
-        # Click "Report Issue" button
-        feedback_button = page.locator('button:has-text("Report Issue")')
-        if feedback_button.is_visible():
-            feedback_button.click()
-            page.wait_for_timeout(500)
-
-            # Fill feedback form
-            textarea = page.locator('textarea[placeholder*="issue"]')
-            textarea.fill("Test feedback: The term 'API' should remain in English.")
-
-            # Submit feedback
-            submit_button = page.locator('button:has-text("Submit Feedback")')
-            submit_button.click()
-            page.wait_for_timeout(2000)
-
-            # Verify success message
-            success_message = page.locator('text=Thank you')
-            if success_message.is_visible(timeout=3000):
-                print("✅ Feedback submitted successfully")
-            else:
-                print("⚠️ Feedback button found but submission uncertain")
-        else:
-            print("⚠️ Feedback button not visible (may need Urdu translation first)")
-
-    def test_08_unauthenticated_user_prompt(self, page: Page):
-        """Test 8: Unauthenticated users see login prompt"""
-        print("\n🧪 Test 8: Unauthenticated user experience")
-
-        # Navigate to chapter without login
-        page.goto(f"{BASE_URL}/docs/intro")
-        page.wait_for_load_state("networkidle")
-
-        # Check if translation button is disabled or shows auth prompt
-        translate_button = page.locator('button:has-text("Translate to Urdu")')
-
-        if translate_button.is_visible():
-            # Click button (should not translate)
-            translate_button.click()
-            page.wait_for_timeout(1000)
-
-            # Should see authentication prompt or redirect to signup
-            auth_prompt = page.locator('text=Login required, text=Sign up, text=login')
-            if auth_prompt.is_visible(timeout=2000):
-                print("✅ Authentication prompt shown to guest users")
-            elif "signup" in page.url.lower() or "login" in page.url.lower():
-                print("✅ Redirected to signup/login page")
-            else:
-                print("⚠️ Authentication handling unclear")
-
-
-# Run tests with: pytest backend/tests/e2e/test_translation_flow.py -v -s
-# Note: Requires backend and frontend servers running:
-#   Terminal 1: cd backend && python3 main.py
-#   Terminal 2: cd frontend && npm start
+"""
+End-to-End Test: Complete Translation Flow
+
+Tests the full user journey:
+1. User signup
+2. Login
+3. Navigate to chapter
+4. Translate to Urdu
+5. Toggle back to English
+6. Submit feedback
+
+Note: Requires Playwright installation:
+    pip install playwright pytest-playwright
+    playwright install
+"""
+
+import pytest
+from playwright.sync_api import Page, expect
+import time
+
+
+# Test configuration
+BASE_URL = "http://localhost:3000"
+API_URL = "http://localhost:8001"
+TEST_USER_EMAIL = f"test_{int(time.time())}@example.com"
+TEST_USER_PASSWORD = "Test1234!"
+
+
+@pytest.fixture(scope="module")
+def browser_context(playwright):
+    """Create browser context for all tests"""
+    browser = playwright.chromium.launch(headless=True)
+    context = browser.new_context(viewport={"width": 1920, "height": 1080})
+    yield context
+    context.close()
+    browser.close()
+
+
+@pytest.fixture
+def page(browser_context):
+    """Create new page for each test"""
+    page = browser_context.new_page()
+    yield page
+    page.close()
+
+
+class TestTranslationE2E:
+    """End-to-end translation flow tests"""
+
+    def test_01_user_signup(self, page: Page):
+        """Test 1: User can sign up with software/hardware background"""
+        print(f"\n🧪 Test 1: Signup with email: {TEST_USER_EMAIL}")
+
+        # Navigate to signup page
+        page.goto(f"{BASE_URL}/signup")
+        page.wait_for_load_state("networkidle")
+
+        # Fill signup form
+        page.fill('input[type="email"]', TEST_USER_EMAIL)
+        page.fill('input[type="password"]', TEST_USER_PASSWORD)
+        page.fill('textarea[placeholder*="software"]', "Python, JavaScript, ROS2")
+        page.fill('textarea[placeholder*="hardware"]', "Arduino, Raspberry Pi")
+
+        # Submit form
+        page.click('button[type="submit"]')
+        page.wait_for_timeout(2000)
+
+        # Verify redirect to homepage or dashboard
+        assert "signup" not in page.url.lower() or "login" in page.url.lower()
+        print("✅ Signup successful")
+
+    def test_02_user_login(self, page: Page):
+        """Test 2: User can login with credentials"""
+        print(f"\n🧪 Test 2: Login with email: {TEST_USER_EMAIL}")
+
+        # Navigate to login page
+        page.goto(f"{BASE_URL}/login")
+        page.wait_for_load_state("networkidle")
+
+        # Fill login form
+        page.fill('input[type="email"]', TEST_USER_EMAIL)
+        page.fill('input[type="password"]', TEST_USER_PASSWORD)
+
+        # Submit form
+        page.click('button[type="submit"]')
+        page.wait_for_timeout(2000)
+
+        # Verify authentication (should see logout or profile)
+        assert "login" not in page.url.lower()
+        print("✅ Login successful")
+
+    def test_03_navigate_to_chapter(self, page: Page):
+        """Test 3: User can navigate to a chapter with translation support"""
+        print("\n🧪 Test 3: Navigate to ROS2 Fundamentals chapter")
+
+        # Login first
+        page.goto(f"{BASE_URL}/login")
+        page.fill('input[type="email"]', TEST_USER_EMAIL)
+        page.fill('input[type="password"]', TEST_USER_PASSWORD)
+        page.click('button[type="submit"]')
+        page.wait_for_timeout(2000)
+
+        # Navigate to chapter with translation support
+        page.goto(f"{BASE_URL}/docs/ros2-fundamentals")
+        page.wait_for_load_state("networkidle")
+
+        # Verify chapter loaded
+        assert "ros2" in page.url.lower() or "fundamentals" in page.url.lower()
+
+        # Verify translation button exists
+        translate_button = page.locator('button:has-text("Translate to Urdu")')
+        expect(translate_button).to_be_visible(timeout=5000)
+        print("✅ Chapter loaded with translation button")
+
+    def test_04_translate_to_urdu(self, page: Page):
+        """Test 4: User can translate chapter to Urdu (first time - API call)"""
+        print("\n🧪 Test 4: Translate chapter to Urdu")
+
+        # Login and navigate to chapter
+        page.goto(f"{BASE_URL}/login")
+        page.fill('input[type="email"]', TEST_USER_EMAIL)
+        page.fill('input[type="password"]', TEST_USER_PASSWORD)
+        page.click('button[type="submit"]')
+        page.wait_for_timeout(2000)
+
+        page.goto(f"{BASE_URL}/docs/intro")
+        page.wait_for_load_state("networkidle")
+
+        # Click translate button
+        translate_button = page.locator('button:has-text("Translate to Urdu")')
+        translate_button.click()
+
+        # Verify loading state appears
+        loading_indicator = page.locator('text=Translating')
+        expect(loading_indicator).to_be_visible(timeout=2000)
+        print("⏳ Loading indicator visible")
+
+        # Wait for translation to complete (8-10 seconds)
+        page.wait_for_timeout(12000)
+
+        # Verify button changed to "View in English"
+        english_button = page.locator('button:has-text("View in English")')
+        expect(english_button).to_be_visible(timeout=15000)
+        print("✅ Translation completed successfully")
+
+        # Verify Urdu content is displayed (check for RTL)
+        # Note: Actual Urdu verification would need OCR or specific text matching
+        page.wait_for_timeout(1000)
+
+    def test_05_toggle_to_english(self, page: Page):
+        """Test 5: User can toggle back to English instantly"""
+        print("\n🧪 Test 5: Toggle back to English")
+
+        # Login, navigate, and translate first
+        page.goto(f"{BASE_URL}/login")
+        page.fill('input[type="email"]', TEST_USER_EMAIL)
+        page.fill('input[type="password"]', TEST_USER_PASSWORD)
+        page.click('button[type="submit"]')
+        page.wait_for_timeout(2000)
+
+        page.goto(f"{BASE_URL}/docs/intro")
+        page.wait_for_load_state("networkidle")
+
+        # Translate to Urdu first
+        translate_button = page.locator('button:has-text("Translate to Urdu")')
+        if translate_button.is_visible():
+            translate_button.click()
+            page.wait_for_timeout(12000)
+
+        # Click "View in English" button
+        english_button = page.locator('button:has-text("View in English")')
+        start_time = time.time()
+        english_button.click()
+
+        # Verify instant toggle (<100ms target, but allow 1s for UI)
+        page.wait_for_timeout(500)
+        urdu_button = page.locator('button:has-text("Translate to Urdu")')
+        expect(urdu_button).to_be_visible(timeout=2000)
+
+        elapsed = time.time() - start_time
+        print(f"✅ Toggled to English in {elapsed:.2f}s (instant)")
+        assert elapsed < 2.0, "Toggle should be instant (<2s)"
+
+    def test_06_cached_translation(self, page: Page):
+        """Test 6: Second translation loads from cache (<1s)"""
+        print("\n🧪 Test 6: Cached translation loading")
+
+        # Login and navigate
+        page.goto(f"{BASE_URL}/login")
+        page.fill('input[type="email"]', TEST_USER_EMAIL)
+        page.fill('input[type="password"]', TEST_USER_PASSWORD)
+        page.click('button[type="submit"]')
+        page.wait_for_timeout(2000)
+
+        page.goto(f"{BASE_URL}/docs/intro")
+        page.wait_for_load_state("networkidle")
+
+        # Ensure we're in English view
+        english_button = page.locator('button:has-text("View in English")')
+        if english_button.is_visible():
+            english_button.click()
+            page.wait_for_timeout(500)
+
+        # Click translate again (should hit cache)
+        translate_button = page.locator('button:has-text("Translate to Urdu")')
+        start_time = time.time()
+        translate_button.click()
+
+        # Wait for translation to complete
+        english_button = page.locator('button:has-text("View in English")')
+        expect(english_button).to_be_visible(timeout=5000)
+
+        elapsed = time.time() - start_time
+        print(f"✅ Cache hit in {elapsed:.2f}s")
+
+        # Verify cache indicator visible
+        cache_indicator = page.locator('text=Loaded from cache')
+        # Cache indicator might not always be visible, so don't assert
+        if cache_indicator.is_visible(timeout=1000):
+            print("⚡ Cache indicator displayed")
+
+    def test_07_submit_feedback(self, page: Page):
+        """Test 7: User can submit translation feedback"""
+        print("\n🧪 Test 7: Submit translation feedback")
+
+        # Login, navigate, and translate
+        page.goto(f"{BASE_URL}/login")
+        page.fill('input[type="email"]', TEST_USER_EMAIL)
+        page.fill('input[type="password"]', TEST_USER_PASSWORD)
+        page.click('button[type="submit"]')
+        page.wait_for_timeout(2000)
+
+        page.goto(f"{BASE_URL}/docs/intro")
+        page.wait_for_load_state("networkidle")
+
+        # Translate to Urdu first
+        translate_button = page.locator('button:has-text("Translate to Urdu")')
+        if translate_button.is_visible():
+            translate_button.click()
+            page.wait_for_timeout(12000)
+
+        # Click "Report Issue" button
+        feedback_button = page.locator('button:has-text("Report Issue")')
+        if feedback_button.is_visible():
+            feedback_button.click()
+            page.wait_for_timeout(500)
+
+            # Fill feedback form
+            textarea = page.locator('textarea[placeholder*="issue"]')
+            textarea.fill("Test feedback: The term 'API' should remain in English.")
+
+            # Submit feedback
+            submit_button = page.locator('button:has-text("Submit Feedback")')
+            submit_button.click()
+            page.wait_for_timeout(2000)
+
+            # Verify success message
+            success_message = page.locator('text=Thank you')
+            if success_message.is_visible(timeout=3000):
+                print("✅ Feedback submitted successfully")
+            else:
+                print("⚠️ Feedback button found but submission uncertain")
+        else:
+            print("⚠️ Feedback button not visible (may need Urdu translation first)")
+
+    def test_08_unauthenticated_user_prompt(self, page: Page):
+        """Test 8: Unauthenticated users see login prompt"""
+        print("\n🧪 Test 8: Unauthenticated user experience")
+
+        # Navigate to chapter without login
+        page.goto(f"{BASE_URL}/docs/intro")
+        page.wait_for_load_state("networkidle")
+
+        # Check if translation button is disabled or shows auth prompt
+        translate_button = page.locator('button:has-text("Translate to Urdu")')
+
+        if translate_button.is_visible():
+            # Click button (should not translate)
+            translate_button.click()
+            page.wait_for_timeout(1000)
+
+            # Should see authentication prompt or redirect to signup
+            auth_prompt = page.locator('text=Login required, text=Sign up, text=login')
+            if auth_prompt.is_visible(timeout=2000):
+                print("✅ Authentication prompt shown to guest users")
+            elif "signup" in page.url.lower() or "login" in page.url.lower():
+                print("✅ Redirected to signup/login page")
+            else:
+                print("⚠️ Authentication handling unclear")
+
+
+# Run tests with: pytest backend/tests/e2e/test_translation_flow.py -v -s
+# Note: Requires backend and frontend servers running:
+#   Terminal 1: cd backend && python3 main.py
+#   Terminal 2: cd frontend && npm start

tests/integration/test_feedback_endpoint.py

@@ -1,126 +1,126 @@
-"""
-Integration tests for Translation Feedback API endpoint
-
-Tests:
-- test_submit_feedback_authenticated: POST /api/translate/feedback with JWT
-- test_submit_feedback_unauthenticated: POST without JWT returns 401
-"""
-
-import pytest
-from fastapi.testclient import TestClient
-from main import app
-from auth.jwt_utils import create_jwt_token
-import uuid
-
-
-client = TestClient(app)
-
-
-def test_submit_feedback_authenticated():
-    """Test submitting feedback with valid JWT token"""
-    # Arrange
-    user_id = str(uuid.uuid4())
-    user_email = "test@example.com"
-    token = create_jwt_token(user_id, user_email)
-
-    translation_id = str(uuid.uuid4())
-    feedback_data = {
-        "translation_id": translation_id,
-        "issue_description": "Technical term 'ROS2' was incorrectly translated to Urdu"
-    }
-
-    # Act
-    response = client.post(
-        "/api/translate/feedback",
-        json=feedback_data,
-        headers={"Authorization": f"Bearer {token}"}
-    )
-
-    # Assert
-    assert response.status_code in [201, 200, 503], f"Expected 201/200/503, got {response.status_code}: {response.text}"
-
-    if response.status_code == 201:
-        data = response.json()
-        assert "feedback_id" in data or "id" in data
-        print(f"✅ Feedback submitted successfully: {data}")
-    elif response.status_code == 503:
-        print("⚠️ Database unavailable (mock mode) - endpoint exists but DB not connected")
-    else:
-        print(f"✅ Feedback endpoint exists: {response.status_code}")
-
-
-def test_submit_feedback_unauthenticated():
-    """Test submitting feedback without JWT token returns 401"""
-    # Arrange
-    feedback_data = {
-        "translation_id": str(uuid.uuid4()),
-        "issue_description": "Translation issue"
-    }
-
-    # Act
-    response = client.post(
-        "/api/translate/feedback",
-        json=feedback_data
-        # No Authorization header
-    )
-
-    # Assert
-    assert response.status_code in [401, 404], f"Expected 401 or 404 (endpoint not implemented yet), got {response.status_code}"
-
-    if response.status_code == 401:
-        print("✅ Unauthenticated request properly rejected with 401")
-    else:
-        print("⚠️ Feedback endpoint not yet implemented (404)")
-
-
-def test_submit_feedback_missing_fields():
-    """Test submitting feedback with missing required fields"""
-    # Arrange
-    user_id = str(uuid.uuid4())
-    user_email = "test@example.com"
-    token = create_jwt_token(user_id, user_email)
-
-    incomplete_data = {
-        "translation_id": str(uuid.uuid4())
-        # Missing issue_description
-    }
-
-    # Act
-    response = client.post(
-        "/api/translate/feedback",
-        json=incomplete_data,
-        headers={"Authorization": f"Bearer {token}"}
-    )
-
-    # Assert
-    assert response.status_code in [422, 400, 404], f"Expected 422/400/404, got {response.status_code}"
-
-    if response.status_code in [422, 400]:
-        print("✅ Validation error properly handled")
-    else:
-        print("⚠️ Endpoint not yet implemented")
-
-
-def test_submit_feedback_invalid_translation_id():
-    """Test submitting feedback with non-existent translation_id"""
-    # Arrange
-    user_id = str(uuid.uuid4())
-    user_email = "test@example.com"
-    token = create_jwt_token(user_id, user_email)
-
-    feedback_data = {
-        "translation_id": str(uuid.uuid4()),  # Non-existent translation
-        "issue_description": "Test issue"
-    }
-
-    # Act
-    response = client.post(
-        "/api/translate/feedback",
-        json=feedback_data,
-        headers={"Authorization": f"Bearer {token}"}
-    )
-
-    # Assert
-    # Should either accept (201) or reject with 404 if FK constraint enforced
-    assert response.status_code in [201, 404, 400, 503], f"Got {response.status_code}"
-    print(f"✅ Invalid translation_id handled: {response.status_code}")
+"""
+Integration tests for Translation Feedback API endpoint
+
+Tests:
+- test_submit_feedback_authenticated: POST /api/translate/feedback with JWT
+- test_submit_feedback_unauthenticated: POST without JWT returns 401
+"""
+
+import pytest
+from fastapi.testclient import TestClient
+from main import app
+from auth.jwt_utils import create_jwt_token
+import uuid
+
+
+client = TestClient(app)
+
+
+def test_submit_feedback_authenticated():
+    """Test submitting feedback with valid JWT token"""
+    # Arrange
+    user_id = str(uuid.uuid4())
+    user_email = "test@example.com"
+    token = create_jwt_token(user_id, user_email)
+
+    translation_id = str(uuid.uuid4())
+    feedback_data = {
+        "translation_id": translation_id,
+        "issue_description": "Technical term 'ROS2' was incorrectly translated to Urdu"
+    }
+
+    # Act
+    response = client.post(
+        "/api/translate/feedback",
+        json=feedback_data,
+        headers={"Authorization": f"Bearer {token}"}
+    )
+
+    # Assert
+    assert response.status_code in [201, 200, 503], f"Expected 201/200/503, got {response.status_code}: {response.text}"
+
+    if response.status_code == 201:
+        data = response.json()
+        assert "feedback_id" in data or "id" in data
+        print(f"✅ Feedback submitted successfully: {data}")
+    elif response.status_code == 503:
+        print("⚠️ Database unavailable (mock mode) - endpoint exists but DB not connected")
+    else:
+        print(f"✅ Feedback endpoint exists: {response.status_code}")
+
+
+def test_submit_feedback_unauthenticated():
+    """Test submitting feedback without JWT token returns 401"""
+    # Arrange
+    feedback_data = {
+        "translation_id": str(uuid.uuid4()),
+        "issue_description": "Translation issue"
+    }
+
+    # Act
+    response = client.post(
+        "/api/translate/feedback",
+        json=feedback_data
+        # No Authorization header
+    )
+
+    # Assert
+    assert response.status_code in [401, 404], f"Expected 401 or 404 (endpoint not implemented yet), got {response.status_code}"
+
+    if response.status_code == 401:
+        print("✅ Unauthenticated request properly rejected with 401")
+    else:
+        print("⚠️ Feedback endpoint not yet implemented (404)")
+
+
+def test_submit_feedback_missing_fields():
+    """Test submitting feedback with missing required fields"""
+    # Arrange
+    user_id = str(uuid.uuid4())
+    user_email = "test@example.com"
+    token = create_jwt_token(user_id, user_email)
+
+    incomplete_data = {
+        "translation_id": str(uuid.uuid4())
+        # Missing issue_description
+    }
+
+    # Act
+    response = client.post(
+        "/api/translate/feedback",
+        json=incomplete_data,
+        headers={"Authorization": f"Bearer {token}"}
+    )
+
+    # Assert
+    assert response.status_code in [422, 400, 404], f"Expected 422/400/404, got {response.status_code}"
+
+    if response.status_code in [422, 400]:
+        print("✅ Validation error properly handled")
+    else:
+        print("⚠️ Endpoint not yet implemented")
+
+
+def test_submit_feedback_invalid_translation_id():
+    """Test submitting feedback with non-existent translation_id"""
+    # Arrange
+    user_id = str(uuid.uuid4())
+    user_email = "test@example.com"
+    token = create_jwt_token(user_id, user_email)
+
+    feedback_data = {
+        "translation_id": str(uuid.uuid4()),  # Non-existent translation
+        "issue_description": "Test issue"
+    }
+
+    # Act
+    response = client.post(
+        "/api/translate/feedback",
+        json=feedback_data,
+        headers={"Authorization": f"Bearer {token}"}
+    )
+
+    # Assert
+    # Should either accept (201) or reject with 404 if FK constraint enforced
+    assert response.status_code in [201, 404, 400, 503], f"Got {response.status_code}"
+    print(f"✅ Invalid translation_id handled: {response.status_code}")

tests/unit/test_feedback_model.py

@@ -1,81 +1,81 @@
-"""
-Unit tests for TranslationFeedback model
-
-Tests:
-- test_create_translation_feedback: Verify feedback creation
-- test_feedback_foreign_key_constraint: Verify FK relationship to translations
-"""
-
-import pytest
-from models.translation_feedback import TranslationFeedback
-from models.translation import Translation
-from database.models import User
-from database.db import get_db_session
-import uuid
-from datetime import datetime
-
-
-@pytest.mark.asyncio
-async def test_create_translation_feedback():
-    """Test creating a translation feedback record"""
-    # Arrange
-    feedback_id = uuid.uuid4()
-    translation_id = uuid.uuid4()
-    user_id = uuid.uuid4()
-    issue_description = "Technical term 'API' was incorrectly translated to Urdu"
-
-    # Act
-    feedback = TranslationFeedback(
-        id=feedback_id,
-        translation_id=translation_id,
-        user_id=user_id,
-        issue_description=issue_description,
-        created_at=datetime.utcnow()
-    )
-
-    # Assert
-    assert feedback.id == feedback_id
-    assert feedback.translation_id == translation_id
-    assert feedback.user_id == user_id
-    assert feedback.issue_description == issue_description
-    assert feedback.created_at is not None
-    print(f"✅ TranslationFeedback model created: {feedback}")
-
-
-@pytest.mark.asyncio
-async def test_feedback_foreign_key_constraint():
-    """Test that feedback links to translation record via FK"""
-    # Arrange
-    translation_id = uuid.uuid4()
-    user_id = uuid.uuid4()
-
-    # Act
-    feedback = TranslationFeedback(
-        id=uuid.uuid4(),
-        translation_id=translation_id,  # FK to translations table
-        user_id=user_id,                # FK to users table
-        issue_description="Translation quality issue",
-        created_at=datetime.utcnow()
-    )
-
-    # Assert
-    assert feedback.translation_id == translation_id
-    assert hasattr(feedback, 'translation_id'), "Feedback must have translation_id FK"
-    assert hasattr(feedback, 'user_id'), "Feedback must have user_id FK"
-    print(f"✅ Foreign key constraint verified: translation_id={translation_id}")
-
-
-def test_feedback_model_repr():
-    """Test __repr__ method for debugging"""
-    feedback = TranslationFeedback(
-        id=uuid.uuid4(),
-        translation_id=uuid.uuid4(),
-        user_id=uuid.uuid4(),
-        issue_description="Test issue",
-        created_at=datetime.utcnow()
-    )
-
-    repr_str = repr(feedback)
-    assert "TranslationFeedback" in repr_str
-    assert "issue_description" in repr_str or "translation_id" in repr_str
-    print(f"✅ Model repr: {repr_str}")
+"""
+Unit tests for TranslationFeedback model
+
+Tests:
+- test_create_translation_feedback: Verify feedback creation
+- test_feedback_foreign_key_constraint: Verify FK relationship to translations
+"""
+
+import pytest
+from models.translation_feedback import TranslationFeedback
+from models.translation import Translation
+from database.models import User
+from database.db import get_db_session
+import uuid
+from datetime import datetime
+
+
+@pytest.mark.asyncio
+async def test_create_translation_feedback():
+    """Test creating a translation feedback record"""
+    # Arrange
+    feedback_id = uuid.uuid4()
+    translation_id = uuid.uuid4()
+    user_id = uuid.uuid4()
+    issue_description = "Technical term 'API' was incorrectly translated to Urdu"
+
+    # Act
+    feedback = TranslationFeedback(
+        id=feedback_id,
+        translation_id=translation_id,
+        user_id=user_id,
+        issue_description=issue_description,
+        created_at=datetime.utcnow()
+    )
+
+    # Assert
+    assert feedback.id == feedback_id
+    assert feedback.translation_id == translation_id
+    assert feedback.user_id == user_id
+    assert feedback.issue_description == issue_description
+    assert feedback.created_at is not None
+    print(f"✅ TranslationFeedback model created: {feedback}")
+
+
+@pytest.mark.asyncio
+async def test_feedback_foreign_key_constraint():
+    """Test that feedback links to translation record via FK"""
+    # Arrange
+    translation_id = uuid.uuid4()
+    user_id = uuid.uuid4()
+
+    # Act
+    feedback = TranslationFeedback(
+        id=uuid.uuid4(),
+        translation_id=translation_id,  # FK to translations table
+        user_id=user_id,                # FK to users table
+        issue_description="Translation quality issue",
+        created_at=datetime.utcnow()
+    )
+
+    # Assert
+    assert feedback.translation_id == translation_id
+    assert hasattr(feedback, 'translation_id'), "Feedback must have translation_id FK"
+    assert hasattr(feedback, 'user_id'), "Feedback must have user_id FK"
+    print(f"✅ Foreign key constraint verified: translation_id={translation_id}")
+
+
+def test_feedback_model_repr():
+    """Test __repr__ method for debugging"""
+    feedback = TranslationFeedback(
+        id=uuid.uuid4(),
+        translation_id=uuid.uuid4(),
+        user_id=uuid.uuid4(),
+        issue_description="Test issue",
+        created_at=datetime.utcnow()
+    )
+
+    repr_str = repr(feedback)
+    assert "TranslationFeedback" in repr_str
+    assert "issue_description" in repr_str or "translation_id" in repr_str
+    print(f"✅ Model repr: {repr_str}")