arionxiv 1.0.32__py3-none-any.whl

arionxiv/utils/__init__.py

@@ -0,0 +1,51 @@
+"""
+Utility functions for ArionXiv
+"""
+
+from .ip_helper import get_public_ip, display_ip_whitelist_help, check_mongodb_connection_error
+from .file_cleanup import file_cleanup_manager, FileCleanupManager
+from .api_helpers import (
+    RegisterRequest,
+    LoginRequest,
+    RefreshTokenRequest,
+    ChatMessageRequest,
+    ChatSessionRequest,
+    LibraryAddRequest,
+    LibraryUpdateRequest,
+    PaperSearchRequest,
+    APIResponse,
+    AuthResponse,
+    PaperListResponse,
+    ChatResponse,
+    create_error_response,
+    handle_service_error,
+    sanitize_arxiv_id,
+    format_user_response,
+    paginate_results
+)
+
+__all__ = [
+    'get_public_ip',
+    'display_ip_whitelist_help',
+    'check_mongodb_connection_error',
+    'file_cleanup_manager',
+    'FileCleanupManager',
+    # API helpers
+    'RegisterRequest',
+    'LoginRequest',
+    'RefreshTokenRequest',
+    'ChatMessageRequest',
+    'ChatSessionRequest',
+    'LibraryAddRequest',
+    'LibraryUpdateRequest',
+    'PaperSearchRequest',
+    'APIResponse',
+    'AuthResponse',
+    'PaperListResponse',
+    'ChatResponse',
+    'create_error_response',
+    'handle_service_error',
+    'sanitize_arxiv_id',
+    'format_user_response',
+    'paginate_results'
+]

arionxiv/utils/api_helpers.py

@@ -0,0 +1,200 @@
+"""
+API Helper utilities for ArionXiv server
+Shared response models, error handlers, and common API utilities
+"""
+
+from typing import Dict, Any, Optional, List
+from datetime import datetime
+from pydantic import BaseModel, Field, field_validator
+from fastapi import HTTPException
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# REQUEST MODELS
+# =============================================================================
+
+class RegisterRequest(BaseModel):
+    """User registration request model"""
+    email: str = Field(..., description="User email address")
+    user_name: str = Field(..., min_length=3, max_length=32, description="Username")
+    password: str = Field(..., min_length=8, description="Password")
+    full_name: Optional[str] = Field(default="", description="Full name")
+    
+    @field_validator('email')
+    @classmethod
+    def validate_email(cls, v: str) -> str:
+        pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+        if not re.match(pattern, v):
+            raise ValueError('Invalid email format')
+        return v.lower().strip()
+    
+    @field_validator('user_name')
+    @classmethod
+    def validate_username(cls, v: str) -> str:
+        v = v.strip().lower()
+        if not re.match(r'^[a-z0-9._-]+$', v):
+            raise ValueError('Username can only contain lowercase letters, numbers, dot, underscore, or hyphen')
+        return v
+
+
+class LoginRequest(BaseModel):
+    """User login request model"""
+    identifier: str = Field(..., description="Email or username")
+    password: str = Field(..., description="Password")
+
+
+class RefreshTokenRequest(BaseModel):
+    """Token refresh request model"""
+    token: str = Field(..., description="Current JWT token to refresh")
+
+
+class ChatMessageRequest(BaseModel):
+    """Chat message request model"""
+    message: str = Field(..., min_length=1, description="User message")
+    paper_id: str = Field(..., description="ArXiv paper ID for context")
+    session_id: Optional[str] = Field(default=None, description="Existing chat session ID")
+    
+
+class ChatSessionRequest(BaseModel):
+    """Create chat session request model"""
+    paper_id: str = Field(..., description="ArXiv paper ID")
+    title: Optional[str] = Field(default=None, description="Session title")
+
+
+class LibraryAddRequest(BaseModel):
+    """Add paper to library request model"""
+    arxiv_id: str = Field(..., description="ArXiv paper ID")
+    tags: Optional[List[str]] = Field(default=None, description="Tags for the paper")
+    notes: Optional[str] = Field(default=None, description="Personal notes")
+
+
+class LibraryUpdateRequest(BaseModel):
+    """Update library paper request model"""
+    tags: Optional[List[str]] = Field(default=None, description="Updated tags")
+    notes: Optional[str] = Field(default=None, description="Updated notes")
+
+
+class PaperSearchRequest(BaseModel):
+    """Paper search request model"""
+    query: str = Field(..., min_length=1, description="Search query")
+    max_results: int = Field(default=10, ge=1, le=100, description="Max results")
+    category: Optional[str] = Field(default=None, description="ArXiv category filter")
+
+
+# =============================================================================
+# RESPONSE MODELS
+# =============================================================================
+
+class APIResponse(BaseModel):
+    """Standard API response wrapper"""
+    success: bool
+    message: Optional[str] = None
+    data: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    timestamp: str = Field(default_factory=lambda: datetime.utcnow().isoformat())
+
+
+class AuthResponse(BaseModel):
+    """Authentication response model"""
+    success: bool
+    message: Optional[str] = None
+    user: Optional[Dict[str, Any]] = None
+    token: Optional[str] = None
+    error: Optional[str] = None
+
+
+class PaperListResponse(BaseModel):
+    """Paper list response model"""
+    papers: List[Dict[str, Any]]
+    count: int
+    total: Optional[int] = None
+
+
+class ChatResponse(BaseModel):
+    """Chat response model"""
+    response: str
+    session_id: str
+    sources: Optional[List[Dict[str, Any]]] = None
+
+
+# =============================================================================
+# ERROR HANDLING
+# =============================================================================
+
+def create_error_response(
+    status_code: int,
+    detail: str,
+    error_type: str = "APIError"
+) -> HTTPException:
+    """Create standardized HTTP exception"""
+    logger.error(f"{error_type}: {detail}")
+    return HTTPException(
+        status_code=status_code,
+        detail={
+            "error": error_type,
+            "message": detail,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    )
+
+
+def handle_service_error(result: Dict[str, Any], operation: str) -> None:
+    """Handle service layer errors and raise appropriate HTTP exceptions"""
+    if not result.get("success", False):
+        error_msg = result.get("error") or result.get("message") or f"{operation} failed"
+        logger.error(f"{operation} failed: {error_msg}")
+        
+        # Map common errors to status codes
+        error_lower = error_msg.lower()
+        if "not found" in error_lower:
+            raise create_error_response(404, error_msg, "NotFoundError")
+        elif "already exists" in error_lower or "already taken" in error_lower:
+            raise create_error_response(409, error_msg, "ConflictError")
+        elif "invalid" in error_lower or "required" in error_lower:
+            raise create_error_response(400, error_msg, "ValidationError")
+        elif "unauthorized" in error_lower or "authentication" in error_lower:
+            raise create_error_response(401, error_msg, "AuthenticationError")
+        else:
+            raise create_error_response(500, error_msg, "InternalError")
+
+
+# =============================================================================
+# UTILITY FUNCTIONS
+# =============================================================================
+
+# Import sanitize_arxiv_id from the consolidated llm_utils module
+from ..services.llm_inference.llm_utils import sanitize_arxiv_id
+
+
+def format_user_response(user: Dict[str, Any]) -> Dict[str, Any]:
+    """Format user data for API response (remove sensitive fields)"""
+    return {
+        "id": str(user.get("_id", user.get("id", ""))),
+        "email": user.get("email", ""),
+        "user_name": user.get("user_name") or user.get("username", ""),
+        "full_name": user.get("full_name", ""),
+        "created_at": user.get("created_at", ""),
+        "last_login": user.get("last_login", "")
+    }
+
+
+def paginate_results(
+    items: List[Any],
+    skip: int = 0,
+    limit: int = 20
+) -> Dict[str, Any]:
+    """Paginate a list of items"""
+    total = len(items)
+    paginated = items[skip:skip + limit]
+    return {
+        "items": paginated,
+        "count": len(paginated),
+        "total": total,
+        "skip": skip,
+        "limit": limit,
+        "has_more": skip + limit < total
+    }

arionxiv/utils/file_cleanup.py

@@ -0,0 +1,150 @@
+"""
+File Cleanup Utility for ArionXiv
+Manages temporary paper downloads and cleanup after usage
+"""
+
+import os
+from pathlib import Path
+from typing import List, Optional
+import logging
+
+from ..arxiv_operations.utils import ArxivUtils
+
+logger = logging.getLogger(__name__)
+
+class FileCleanupManager:
+    """Manages cleanup of downloaded paper files"""
+    
+    def __init__(self):
+        # Get the downloads directory
+        self.downloads_dir = self._get_downloads_dir()
+    
+    def _get_downloads_dir(self) -> Path:
+        """Get the downloads directory path"""
+        # Default to project root downloads directory
+        project_root = Path(__file__).parent.parent.parent
+        downloads_dir = project_root / "downloads"
+        downloads_dir.mkdir(exist_ok=True)
+        return downloads_dir
+    
+    def cleanup_paper_files(self, paper_id: str) -> bool:
+        """
+        Delete all files associated with a paper ID
+        
+        Args:
+            paper_id: ArXiv paper ID (e.g., "1706.03762")
+            
+        Returns:
+            bool: True if cleanup was successful
+        """
+        try:
+            # Clean version IDs from paper_id using normalized function
+            clean_id = ArxivUtils.normalize_arxiv_id(paper_id)
+            
+            deleted_count = 0
+            
+            # Find all files matching the paper ID pattern
+            patterns = [
+                f"{clean_id}*.pdf",
+                f"{clean_id}*.txt",
+                f"*{clean_id}*.pdf",
+                f"*{clean_id}*.txt"
+            ]
+            
+            for pattern in patterns:
+                matching_files = list(self.downloads_dir.glob(pattern))
+                for file_path in matching_files:
+                    try:
+                        file_path.unlink()
+                        deleted_count += 1
+                        logger.info(f"Deleted file: {file_path.name}")
+                    except Exception as e:
+                        logger.warning(f"Failed to delete {file_path.name}: {e}")
+            
+            if deleted_count > 0:
+                logger.info(f"Cleaned up {deleted_count} files for paper {paper_id}")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to cleanup files for paper {paper_id}: {e}")
+            return False
+    
+    def cleanup_multiple_papers(self, paper_ids: List[str]) -> int:
+        """
+        Cleanup files for multiple papers
+        
+        Args:
+            paper_ids: List of paper IDs to cleanup
+            
+        Returns:
+            int: Number of papers successfully cleaned up
+        """
+        success_count = 0
+        for paper_id in paper_ids:
+            if self.cleanup_paper_files(paper_id):
+                success_count += 1
+        
+        return success_count
+    
+    def get_paper_files(self, paper_id: str) -> List[Path]:
+        """
+        Get all files associated with a paper ID
+        
+        Args:
+            paper_id: ArXiv paper ID
+            
+        Returns:
+            List[Path]: List of file paths for the paper
+        """
+        try:
+            # Clean version IDs from paper_id using normalized function
+            clean_id = ArxivUtils.normalize_arxiv_id(paper_id)
+            
+            files = []
+            
+            # Find all files matching the paper ID pattern
+            patterns = [
+                f"{clean_id}*.pdf",
+                f"{clean_id}*.txt",
+                f"*{clean_id}*.pdf",
+                f"*{clean_id}*.txt"
+            ]
+            
+            for pattern in patterns:
+                matching_files = list(self.downloads_dir.glob(pattern))
+                files.extend(matching_files)
+            
+            return files
+            
+        except Exception as e:
+            logger.error(f"Failed to get files for paper {paper_id}: {e}")
+            return []
+    
+    def cleanup_all_downloads(self) -> int:
+        """
+        Clean up all downloaded files
+        
+        Returns:
+            int: Number of files deleted
+        """
+        try:
+            deleted_count = 0
+            
+            for file_path in self.downloads_dir.glob("*"):
+                if file_path.is_file() and file_path.suffix in ['.pdf', '.txt']:
+                    try:
+                        file_path.unlink()
+                        deleted_count += 1
+                    except Exception as e:
+                        logger.warning(f"Failed to delete {file_path.name}: {e}")
+            
+            logger.info(f"Cleaned up {deleted_count} total files")
+            return deleted_count
+            
+        except Exception as e:
+            logger.error(f"Failed to cleanup all downloads: {e}")
+            return 0
+
+# Global instance
+file_cleanup_manager = FileCleanupManager()

arionxiv/utils/ip_helper.py

@@ -0,0 +1,96 @@
+"""
+IP Detection Helper for MongoDB Atlas Connection Issues
+"""
+
+import requests
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def get_public_ip():
+    """Get current public IP address"""
+    try:
+        response = requests.get('https://api.ipify.org?format=json', timeout=5)
+        ip = response.json().get('ip')
+        return ip
+    except Exception as e:
+        logger.warning(f"Failed to get public IP via ipify: {e}")
+        
+    # Fallback methods
+    fallback_services = [
+        'https://icanhazip.com',
+        'https://ident.me',
+        'https://ipecho.net/plain'
+    ]
+    
+    for service in fallback_services:
+        try:
+            response = requests.get(service, timeout=5)
+            ip = response.text.strip()
+            if ip:
+                return ip
+        except Exception:
+            continue
+    
+    return None
+
+
+def display_ip_whitelist_help(current_ip=None):
+    """Display helpful message about IP whitelisting"""
+    if current_ip is None:
+        current_ip = get_public_ip()
+    
+    message = "\n" + "="*70 + "\n"
+    message += "MongoDB Atlas IP Whitelisting Issue Detected\n"
+    message += "="*70 + "\n"
+    
+    if current_ip:
+        message += f"\nYour current public IP: {current_ip}\n"
+    else:
+        message += "\nCould not detect your current IP automatically.\n"
+    
+    message += "\nSolutions:\n"
+    message += "\n1. FOR DEVELOPMENT (Recommended):"
+    message += "\n   - Go to MongoDB Atlas Dashboard"
+    message += "\n   - Network Access > IP Access List"
+    message += "\n   - Click 'Add IP Address'"
+    message += "\n   - Select 'Allow Access from Anywhere' (0.0.0.0/0)"
+    message += "\n   - This allows all IPs and solves your issue permanently for dev"
+    
+    message += "\n\n2. FOR PRODUCTION (More Secure):"
+    if current_ip:
+        message += f"\n   - Add your current IP: {current_ip}"
+    message += "\n   - Use a static IP or VPN"
+    message += "\n   - Configure IP ranges for your infrastructure"
+    
+    message += "\n\n3. ALTERNATIVE: Use MongoDB Connection String with srv+mongodb://"
+    message += "\n   - Some ISPs work better with direct connections"
+    
+    message += "\n\nMongoDB Atlas Dashboard:"
+    message += "\n   https://cloud.mongodb.com/"
+    
+    message += "\n\n" + "="*70 + "\n"
+    
+    logger.warning(message)
+
+
+def check_mongodb_connection_error(error_message):
+    """Check if error is related to IP whitelisting and provide help"""
+    ip_whitelist_indicators = [
+        "not authorized",
+        "IP address is not whitelisted",
+        "connection refused",
+        "timed out",
+        "network access",
+        "authentication failed"
+    ]
+    
+    error_lower = str(error_message).lower()
+    
+    for indicator in ip_whitelist_indicators:
+        if indicator in error_lower:
+            display_ip_whitelist_help()
+            return True
+    
+    return False