arionxiv 1.0.32__py3-none-any.whl

arionxiv/cli/utils/db_config_manager.py

@@ -0,0 +1,254 @@
+"""Enhanced Configuration Manager with Database Integration"""
+
+import os
+import json
+import asyncio
+from pathlib import Path
+from typing import Dict, Any, Optional
+from rich.console import Console
+
+# Import from parent directory
+import sys
+backend_path = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(backend_path))
+
+from ..ui.global_theme_manager import global_theme_manager
+from ...services.unified_user_service import unified_user_service
+
+console = Console()
+
+class DatabaseConfigManager:
+    """Manages CLI configuration with database integration for authenticated users"""
+    
+    def __init__(self):
+        self.config_dir = Path.home() / ".arionxiv"
+        self.local_config_file = self.config_dir / "local_config.json"
+        self.config = {}
+        self._initialized = False
+        
+        # Ensure directories exist
+        self.config_dir.mkdir(exist_ok=True)
+    
+    def _ensure_initialized(self):
+        """Ensure basic initialization without async calls"""
+        if not self._initialized:
+            try:
+                self.config = self._load_local_config()
+                self._initialized = True
+            except Exception:
+                self.config = self.get_default_config()
+                self._initialized = True
+    
+    async def load_config(self, quiet: bool = True) -> Dict[str, Any]:
+        """Load configuration (from database if authenticated, local otherwise)"""
+        try:
+            # Check if user is authenticated
+            if unified_user_service.is_authenticated():
+                return await self._load_from_database(quiet=quiet)
+            else:
+                return self._load_local_config(quiet=quiet)
+        except Exception:
+            # Silently fall back to defaults - no need to spam console
+            return self.get_default_config()
+    
+    async def _load_from_database(self, quiet: bool = True) -> Dict[str, Any]:
+        """Load configuration - uses local config (hosted API handles cloud data)"""
+        # With hosted Vercel API, we don't need local MongoDB
+        # Settings are synced via API, local config is used for CLI preferences
+        return self._load_local_config(quiet=quiet)
+    
+    def _load_local_config(self, quiet: bool = True) -> Dict[str, Any]:
+        """Load configuration from local file"""
+        try:
+            if self.local_config_file.exists():
+                with open(self.local_config_file, 'r') as f:
+                    self.config = json.load(f)
+            else:
+                self.config = self.get_default_config()
+                self._save_local_config()
+            
+            self.config["database_mode"] = False
+            return self.config
+            
+        except Exception:
+            # Silently fall back to defaults
+            self.config = self.get_default_config()
+            self.config["database_mode"] = False
+            return self.config
+    
+    def _save_local_config(self) -> bool:
+        """Save configuration to local file"""
+        try:
+            with open(self.local_config_file, 'w') as f:
+                json.dump(self.config, f, indent=2)
+            return True
+        except Exception as e:
+            console.print(f"[red]Error saving local config: {e}[/red]")
+            return False
+    
+    async def save_config(self) -> bool:
+        """Save configuration (to database if authenticated, local otherwise)"""
+        try:
+            if unified_user_service.is_authenticated():
+                return await self._save_to_database()
+            else:
+                return self._save_local_config()
+        except Exception as e:
+            console.print(f"[red]Error saving config: {e}[/red]")
+            return False
+    
+    async def _save_to_database(self) -> bool:
+        """Save configuration locally (hosted API handles cloud sync separately)"""
+        # With hosted Vercel API, we save locally and API syncs settings
+        return self._save_local_config()
+    
+    def get_default_config(self) -> Dict[str, Any]:
+        """Get default configuration"""
+        return {
+            "user": {
+                "id": "",
+                "user_name": "",
+                "email": "",
+                "full_name": "",
+                "preferences": {
+                    "categories": ["cs.AI", "cs.LG", "cs.CL"],
+                    "keywords": [],
+                    "max_daily_papers": 10,
+                    "analysis_depth": "standard",
+                    "auto_download": False,
+                    "email_notifications": False
+                }
+            },
+            "display": {
+                "theme": "auto",
+                "theme_color": "blue",
+                "table_style": "grid",
+                "show_abstracts": True,
+                "max_abstract_length": 200,
+                "papers_per_page": 10
+            },
+            "paths": {
+                "downloads": str(self.config_dir / "downloads"),
+                "data": str(self.config_dir / "data"),
+                "cache": str(self.config_dir / "data" / "cache")
+            },
+            "first_time_user": True,
+            "database_mode": False
+        }
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get configuration value using dot notation"""
+        self._ensure_initialized()
+        keys = key.split('.')
+        value = self.config
+        for k in keys:
+            if isinstance(value, dict) and k in value:
+                value = value[k]
+            else:
+                return default
+        return value
+    
+    async def set(self, key: str, value: Any) -> bool:
+        """Set configuration value using dot notation"""
+        keys = key.split('.')
+        config = self.config
+        for k in keys[:-1]:
+            if k not in config:
+                config[k] = {}
+            config = config[k]
+        config[keys[-1]] = value
+        return await self.save_config()
+    
+    async def update_user_preferences(self, preferences: Dict[str, Any]) -> bool:
+        """Update user preferences"""
+        if "user" not in self.config:
+            self.config["user"] = {}
+        if "preferences" not in self.config["user"]:
+            self.config["user"]["preferences"] = {}
+        
+        self.config["user"]["preferences"].update(preferences)
+        return await self.save_config()
+    
+    def is_theme_configured(self) -> bool:
+        """Check if theme color has been configured by user"""
+        # If authenticated, theme is always considered configured
+        if unified_user_service.is_authenticated():
+            return True
+        return self.get("display.theme_color_configured", False)
+    
+    async def set_theme_color(self, color: str) -> bool:
+        """Set the theme color and mark as configured"""
+        success = await self.set("display.theme_color", color)
+        if success:
+            # Update global theme manager
+            try:
+                global_theme_manager.set_theme(color)
+            except Exception:
+                pass  # Silently ignore if theme manager not available
+            
+            if not unified_user_service.is_authenticated():
+                # Only set configured flag for local config
+                success = await self.set("display.theme_color_configured", True)
+        return success
+    
+    def get_theme_color(self) -> str:
+        """Get the current theme color"""
+        self._ensure_initialized()
+        color = self.get("display.theme_color", "blue")
+        
+        # Sync with global theme manager
+        try:
+            current = global_theme_manager.get_current_theme()
+            if current != color:
+                global_theme_manager.set_theme(color)
+        except Exception:
+            pass  # Silently ignore if theme manager not available
+        
+        return color
+    
+    def is_authenticated(self) -> bool:
+        """Check if user is authenticated"""
+        try:
+            return unified_user_service.is_authenticated()
+        except Exception:
+            return False
+    
+    def get_current_user(self) -> Optional[Dict[str, Any]]:
+        """Get current authenticated user"""
+        try:
+            return unified_user_service.get_current_user()
+        except Exception:
+            return None
+    
+    def is_database_mode(self) -> bool:
+        """Check if running in database mode"""
+        self._ensure_initialized()
+        return self.get("database_mode", False)
+    
+    async def reset_config(self) -> bool:
+        """Reset configuration to defaults"""
+        # Reset local config (hosted API handles cloud settings separately)
+        self.config = self.get_default_config()
+        return self._save_local_config()
+
+# Global configuration manager instance
+db_config_manager = DatabaseConfigManager()
+
+# For backward compatibility
+def DbConfigManager():
+    """Factory function to get config manager"""
+    return db_config_manager
+
+# Async wrapper for backward compatibility
+def load_config_sync():
+    """Synchronous wrapper for loading config"""
+    try:
+        loop = asyncio.get_event_loop()
+        return loop.run_until_complete(db_config_manager.load_config())
+    except:
+        return db_config_manager.get_default_config()
+
+# Helper function for synchronous access to default config
+def get_default_config():
+    """Get default config synchronously"""
+    return db_config_manager.get_default_config()

arionxiv/github_actions_runner.py

@@ -0,0 +1,206 @@
+"""
+GitHub Actions Runner for ArionXiv Daily Dose
+
+This module is executed by GitHub Actions to run daily dose for users
+who have their scheduled time matching the current hour (UTC).
+
+Usage:
+    python -m arionxiv.github_actions_runner
+
+Environment Variables:
+    MONGODB_URI: MongoDB connection string (required)
+    OPENROUTER_API_KEY: OpenRouter API key for LLM (required, FREE tier available)
+    GEMINI_API_KEY: Gemini API key for embeddings (optional)
+    GROQ_API_KEY: Groq API key as fallback LLM (optional)
+    FORCE_HOUR: Force run for specific hour (optional, for testing)
+"""
+
+import asyncio
+import logging
+import os
+import sys
+from datetime import datetime, timezone
+from typing import List, Dict, Any
+
+# Configure logging for GitHub Actions
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler(sys.stdout)]
+)
+logger = logging.getLogger(__name__)
+
+
+async def get_users_for_hour(hour: int) -> List[Dict[str, Any]]:
+    """
+    Get all users who have daily dose enabled and scheduled for the given hour.
+    
+    Args:
+        hour: Hour in 24-hour format (0-23)
+        
+    Returns:
+        List of user documents matching the scheduled hour
+    """
+    from .services.unified_database_service import unified_database_service
+    
+    try:
+        # Connect to MongoDB
+        await unified_database_service.connect_mongodb()
+        
+        # Query users with daily dose enabled and matching hour
+        # Time format is "HH:MM", so we match the hour part
+        hour_prefix = f"{hour:02d}:"
+        
+        # Access users collection directly via db attribute
+        users_collection = unified_database_service.db.users
+        
+        # Find users where:
+        # 1. Daily dose is enabled
+        # 2. Scheduled time starts with the current hour
+        query = {
+            "$or": [
+                # Vercel API format: settings.daily_dose.enabled and settings.daily_dose.scheduled_time
+                {
+                    "settings.daily_dose.enabled": True,
+                    "settings.daily_dose.scheduled_time": {"$regex": f"^{hour_prefix}"}
+                },
+                # New format: preferences.daily_dose.enabled and preferences.daily_dose.scheduled_time
+                {
+                    "preferences.daily_dose.enabled": True,
+                    "preferences.daily_dose.scheduled_time": {"$regex": f"^{hour_prefix}"}
+                },
+                # Legacy format: preferences.daily_dose_enabled and preferences.daily_dose_time
+                {
+                    "preferences.daily_dose_enabled": True,
+                    "preferences.daily_dose_time": {"$regex": f"^{hour_prefix}"}
+                }
+            ]
+        }
+        
+        cursor = users_collection.find(query)
+        users = await cursor.to_list(length=None)
+        
+        logger.info(f"Found {len(users)} users scheduled for hour {hour:02d}:00 UTC")
+        return users
+        
+    except Exception as e:
+        logger.error(f"Error fetching users for hour {hour}: {e}")
+        return []
+
+
+async def run_daily_dose_for_user(user_id: str, user_email: str) -> bool:
+    """
+    Run daily dose for a specific user.
+    
+    Args:
+        user_id: MongoDB user ID
+        user_email: User email for logging
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    from .services.unified_daily_dose_service import unified_daily_dose_service
+    
+    try:
+        logger.info(f"Running daily dose for user: {user_email}")
+        
+        # execute_daily_dose is the correct method name
+        result = await unified_daily_dose_service.execute_daily_dose(user_id)
+        
+        if result.get("success"):
+            papers_count = result.get("papers_count", 0)
+            logger.info(f"Daily dose completed for {user_email}: {papers_count} papers analyzed")
+            return True
+        else:
+            error = result.get("message", "Unknown error")
+            logger.error(f"Daily dose failed for {user_email}: {error}")
+            return False
+            
+    except Exception as e:
+        logger.error(f"Exception running daily dose for {user_email}: {e}")
+        return False
+
+
+async def main():
+    """Main entry point for GitHub Actions runner."""
+    from .services.unified_database_service import unified_database_service
+    
+    logger.info("=" * 60)
+    logger.info("ArionXiv Daily Dose - GitHub Actions Runner")
+    logger.info("=" * 60)
+    
+    # Check required environment variables
+    # OpenRouter is the primary LLM provider (FREE tier available)
+    required_vars = ["MONGODB_URI", "OPENROUTER_API_KEY"]
+    missing_vars = [var for var in required_vars if not os.environ.get(var)]
+    
+    if missing_vars:
+        logger.error(f"Missing required environment variables: {', '.join(missing_vars)}")
+        logger.error("Please add these as GitHub Actions secrets.")
+        logger.error("Get a FREE OpenRouter API key at: https://openrouter.ai/")
+        sys.exit(1)
+    
+    # Determine the hour to process
+    force_hour = os.environ.get("FORCE_HOUR", "").strip()
+    
+    if force_hour:
+        try:
+            current_hour = int(force_hour)
+            if not 0 <= current_hour <= 23:
+                raise ValueError("Hour must be between 0 and 23")
+            logger.info(f"Using forced hour: {current_hour:02d}:00 UTC")
+        except ValueError as e:
+            logger.error(f"Invalid FORCE_HOUR value '{force_hour}': {e}")
+            sys.exit(1)
+    else:
+        current_hour = datetime.now(timezone.utc).hour
+        logger.info(f"Current time: {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')} UTC")
+        logger.info(f"Processing hour: {current_hour:02d}:00 UTC")
+    
+    try:
+        # Get users scheduled for this hour
+        users = await get_users_for_hour(current_hour)
+        
+        if not users:
+            logger.info(f"No users scheduled for {current_hour:02d}:00 UTC. Exiting.")
+            return
+        
+        # Process each user
+        success_count = 0
+        failure_count = 0
+        
+        for user in users:
+            user_id = str(user["_id"])
+            user_email = user.get("email", "unknown")
+            
+            if await run_daily_dose_for_user(user_id, user_email):
+                success_count += 1
+            else:
+                failure_count += 1
+            
+            # Small delay between users to avoid rate limiting
+            await asyncio.sleep(2)
+        
+        # Summary
+        logger.info("=" * 60)
+        logger.info("Daily Dose Run Complete")
+        logger.info(f"  Successful: {success_count}")
+        logger.info(f"  Failed: {failure_count}")
+        logger.info(f"  Total: {len(users)}")
+        logger.info("=" * 60)
+        
+        # Exit with error if any failures
+        if failure_count > 0:
+            sys.exit(1)
+    
+    finally:
+        # Always cleanup database connection
+        try:
+            await unified_database_service.disconnect()
+            logger.info("Database connection closed")
+        except Exception as e:
+            logger.warning(f"Error closing database connection: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

arionxiv/main.py

@@ -0,0 +1,23 @@
+"""
+Main CLI entry point for ArionXiv package
+"""
+
+import sys
+import logging
+
+logger = logging.getLogger(__name__)
+
+def main():
+    """Main entry point for the arionxiv CLI command"""
+    try:        
+        from .cli.main import cli
+        cli()
+    except KeyboardInterrupt:
+        logger.info("Operation cancelled by user")
+        sys.exit(0)
+    except Exception as e:
+        logger.error(f"CLI error: {e}", exc_info=True)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

arionxiv/prompts/__init__.py

@@ -0,0 +1,9 @@
+"""Public interface for the prompts module."""
+
+from .prompts import format_prompt, format_prompt_async, get_all_prompts
+
+__all__ = [
+    'format_prompt',
+    'format_prompt_async', 
+    'get_all_prompts'
+]