local-deep-research 0.1.26__py3-none-any.whl → 0.2.2__py3-none-any.whl

local_deep_research/advanced_search_system/questions/standard_question.py

@@ -0,0 +1,119 @@
+"""
+Standard question generation implementation.
+"""
+
+import logging
+from datetime import datetime
+from typing import List
+
+from .base_question import BaseQuestionGenerator
+
+logger = logging.getLogger(__name__)
+
+
+class StandardQuestionGenerator(BaseQuestionGenerator):
+    """Standard question generator."""
+
+    def generate_questions(
+        self,
+        current_knowledge: str,
+        query: str,
+        questions_per_iteration: int = 2,
+        questions_by_iteration: dict = None,
+    ) -> List[str]:
+        """Generate follow-up questions based on current knowledge."""
+        now = datetime.now()
+        current_time = now.strftime("%Y-%m-%d")
+        questions_by_iteration = questions_by_iteration or {}
+
+        logger.info("Generating follow-up questions...")
+
+        if questions_by_iteration:
+            prompt = f"""Critically reflect current knowledge (e.g., timeliness), what {questions_per_iteration} high-quality internet search questions remain unanswered to exactly answer the query?
+            Query: {query}
+            Today: {current_time}
+            Past questions: {str(questions_by_iteration)}
+            Knowledge: {current_knowledge}
+            Include questions that critically reflect current knowledge.
+            \n\n\nFormat: One question per line, e.g. \n Q: question1 \n Q: question2\n\n"""
+        else:
+            prompt = f" You will have follow up questions. First, identify if your knowledge is outdated (high chance). Today: {current_time}. Generate {questions_per_iteration} high-quality internet search questions to exactly answer: {query}\n\n\nFormat: One question per line, e.g. \n Q: question1 \n Q: question2\n\n"
+
+        response = self.model.invoke(prompt)
+
+        # Handle both string responses and responses with .content attribute
+        response_text = ""
+        if hasattr(response, "content"):
+            response_text = response.content
+        else:
+            # Handle string responses
+            response_text = str(response)
+
+        questions = [
+            q.replace("Q:", "").strip()
+            for q in response_text.split("\n")
+            if q.strip().startswith("Q:")
+        ][:questions_per_iteration]
+
+        logger.info(f"Generated {len(questions)} follow-up questions")
+
+        return questions
+
+    def generate_sub_questions(self, query: str, context: str = "") -> List[str]:
+        """
+        Generate sub-questions from a main query.
+
+        Args:
+            query: The main query to break down
+            context: Additional context for question generation
+
+        Returns:
+            List[str]: List of generated sub-questions
+        """
+        prompt = f"""You are an expert at breaking down complex questions into simpler sub-questions.
+
+Original Question: {query}
+
+{context}
+
+Break down the original question into 2-5 simpler sub-questions that would help answer the original question when answered in sequence.
+Follow these guidelines:
+1. Each sub-question should be specific and answerable on its own
+2. Sub-questions should build towards answering the original question
+3. For multi-hop or complex queries, identify the individual facts or entities needed
+4. Ensure the sub-questions can be answered with separate searches
+
+Format your response as a numbered list with ONLY the sub-questions, one per line:
+1. First sub-question
+2. Second sub-question
+...
+
+Only provide the numbered sub-questions, nothing else."""
+
+        try:
+            response = self.model.invoke(prompt)
+
+            # Handle both string responses and responses with .content attribute
+            content = ""
+            if hasattr(response, "content"):
+                content = response.content
+            else:
+                # Handle string responses
+                content = str(response)
+
+            # Parse sub-questions from the response
+            sub_questions = []
+            for line in content.strip().split("\n"):
+                line = line.strip()
+                if line and (line[0].isdigit() or line.startswith("-")):
+                    # Extract sub-question from numbered or bulleted list
+                    parts = line.split(".", 1) if "." in line else line.split(" ", 1)
+                    if len(parts) > 1:
+                        sub_question = parts[1].strip()
+                        sub_questions.append(sub_question)
+
+            # Limit to at most 5 sub-questions
+            return sub_questions[:5]
+        except Exception as e:
+            logger.error(f"Error generating sub-questions: {str(e)}")
+            return []

local_deep_research/advanced_search_system/repositories/__init__.py

@@ -0,0 +1,7 @@
+"""
+Repositories package for advanced search system.
+"""
+
+from ..findings.repository import FindingsRepository
+
+__all__ = ["FindingsRepository"]

local_deep_research/advanced_search_system/strategies/__init__.py

@@ -0,0 +1 @@
+# Search System Strategies Package

local_deep_research/advanced_search_system/strategies/base_strategy.py

@@ -0,0 +1,118 @@
+"""
+Base class for all search strategies.
+Defines the common interface and shared functionality for different search approaches.
+"""
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Callable, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class BaseSearchStrategy(ABC):
+    """Abstract base class for all search strategies."""
+
+    def __init__(self):
+        """Initialize the base strategy with common attributes."""
+        self.progress_callback = None
+        self.questions_by_iteration = {}
+        self.all_links_of_system = []
+
+    def set_progress_callback(self, callback: Callable[[str, int, dict], None]) -> None:
+        """Set a callback function to receive progress updates."""
+        self.progress_callback = callback
+
+    def _update_progress(
+        self,
+        message: str,
+        progress_percent: Optional[int] = None,
+        metadata: Optional[dict] = None,
+    ) -> None:
+        """Send a progress update via the callback if available."""
+        if self.progress_callback:
+            self.progress_callback(message, progress_percent, metadata or {})
+
+    @abstractmethod
+    def analyze_topic(self, query: str) -> Dict:
+        """
+        Analyze a topic using the strategy's specific approach.
+
+        Args:
+            query: The research query to analyze
+
+        Returns:
+            Dict containing:
+            - findings: List of research findings
+            - iterations: Number of iterations completed
+            - questions: Questions generated by iteration
+            - formatted_findings: Formatted output
+            - current_knowledge: Accumulated knowledge
+            - error: Optional error message
+        """
+        pass
+
+    def _validate_search_engine(self) -> bool:
+        """
+        Validate that the search engine is available and configured.
+
+        Returns:
+            bool: True if search engine is available, False otherwise
+        """
+        if not hasattr(self, "search") or self.search is None:
+            error_msg = (
+                "Error: No search engine available. Please check your configuration."
+            )
+            self._update_progress(
+                error_msg,
+                100,
+                {
+                    "phase": "error",
+                    "error": "No search engine available",
+                    "status": "failed",
+                },
+            )
+            return False
+        return True
+
+    def _handle_search_error(
+        self, error: Exception, question: str, progress_base: int
+    ) -> List:
+        """
+        Handle errors during search execution.
+
+        Args:
+            error: The exception that occurred
+            question: The question being searched
+            progress_base: The current progress percentage
+
+        Returns:
+            List: Empty list to continue processing
+        """
+        error_msg = f"Error during search: {str(error)}"
+        logger.error(f"SEARCH ERROR: {error_msg}")
+        self._update_progress(
+            error_msg,
+            progress_base + 2,
+            {"phase": "search_error", "error": str(error)},
+        )
+        return []
+
+    def _handle_analysis_error(
+        self, error: Exception, question: str, progress_base: int
+    ) -> None:
+        """
+        Handle errors during result analysis.
+
+        Args:
+            error: The exception that occurred
+            question: The question being analyzed
+            progress_base: The current progress percentage
+        """
+        error_msg = f"Error analyzing results: {str(error)}"
+        logger.info(f"ANALYSIS ERROR: {error_msg}")
+        self._update_progress(
+            error_msg,
+            progress_base + 10,
+            {"phase": "analysis_error", "error": str(error)},
+        )