Base code

backend/services/linkedin/research_handler.py

@@ -0,0 +1,76 @@
+"""
+Research Handler for LinkedIn Content Generation
+
+Handles research operations and timing for content generation.
+"""
+
+from typing import List
+from datetime import datetime
+from loguru import logger
+from models.linkedin_models import ResearchSource
+
+
+class ResearchHandler:
+    """Handles research operations and timing for LinkedIn content."""
+    
+    def __init__(self, linkedin_service):
+        self.linkedin_service = linkedin_service
+    
+    async def conduct_research(
+        self,
+        request,
+        research_enabled: bool,
+        search_engine: str,
+        max_results: int = 10
+    ) -> tuple[List[ResearchSource], float]:
+        """
+        Conduct research if enabled and return sources with timing.
+        
+        Returns:
+            Tuple of (research_sources, research_time)
+        """
+        research_sources = []
+        research_time = 0
+        
+        if research_enabled:
+            # Debug: Log the search engine value being passed
+            logger.info(f"ResearchHandler: search_engine='{search_engine}' (type: {type(search_engine)})")
+            
+            research_start = datetime.now()
+            research_sources = await self.linkedin_service._conduct_research(
+                topic=request.topic,
+                industry=request.industry,
+                search_engine=search_engine,
+                max_results=max_results
+            )
+            research_time = (datetime.now() - research_start).total_seconds()
+            logger.info(f"Research completed in {research_time:.2f}s, found {len(research_sources)} sources")
+        
+        return research_sources, research_time
+    
+    def determine_grounding_enabled(self, request, research_sources: List[ResearchSource]) -> bool:
+        """Determine if grounding should be enabled based on request and research results."""
+        # Normalize values from possible Enum or string
+        try:
+            level_raw = getattr(request, 'grounding_level', 'enhanced')
+            level = (getattr(level_raw, 'value', level_raw) or '').strip().lower()
+        except Exception:
+            level = 'enhanced'
+        try:
+            engine_raw = getattr(request, 'search_engine', 'google')
+            engine_val = getattr(engine_raw, 'value', engine_raw)
+            engine_str = str(engine_val).split('.')[-1].strip().lower()
+        except Exception:
+            engine_str = 'google'
+        research_enabled = bool(getattr(request, 'research_enabled', True))
+        
+        if not research_enabled or level == 'none':
+            return False
+        
+        # For Google native grounding, Gemini returns sources in the generation metadata,
+        # so we should not require pre-fetched research_sources.
+        if engine_str == 'google':
+            return True
+        
+        # For other engines, require that research actually returned sources
+        return bool(research_sources)