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

local_deep_research/report_generator.py

@@ -1,16 +1,42 @@
-from typing import Dict, List, Optional
-from .config import get_llm
-import re
-from datetime import datetime
+import importlib
+from typing import Dict, List
+
+from langchain_core.language_models import BaseChatModel
+
+# Fix circular import by importing directly from source modules
+from .config.llm_config import get_llm
 from .search_system import AdvancedSearchSystem
-from local_deep_research import config
-from . import utilties
-from .utilties import search_utilities
+from .utilities import search_utilities
+
+
+def get_report_generator(search_system=None):
+    """Return an instance of the report generator with default settings.
+
+    Args:
+        search_system: Optional existing AdvancedSearchSystem to use
+    """
+    return IntegratedReportGenerator(search_system=search_system)
+
 
 class IntegratedReportGenerator:
-    def __init__(self, searches_per_section: int = 2):
-        self.model = get_llm()
-        self.search_system = AdvancedSearchSystem()
+    def __init__(
+        self,
+        searches_per_section: int = 2,
+        search_system=None,
+        llm: BaseChatModel | None = None,
+    ):
+        """
+        Args:
+            searches_per_section: Number of searches to perform for each
+                section in the report.
+            search_system: Custom search system to use, otherwise just uses
+                the default.
+            llm: Custom LLM to use, otherwise just uses the default.
+
+        """
+        self.model = llm or get_llm()
+        # Use provided search_system or create a new one
+        self.search_system = search_system or AdvancedSearchSystem(llm=self.model)
         self.searches_per_section = (
             searches_per_section  # Control search depth per section
         )
@@ -22,17 +48,16 @@ class IntegratedReportGenerator:
         structure = self._determine_report_structure(initial_findings, query)
 
         # Step 2: Research and generate content for each section in one step
-        sections = self._research_and_generate_sections(initial_findings, structure, query)
+        sections = self._research_and_generate_sections(
+            initial_findings, structure, query
+        )
 
         # Step 3: Format final report
         report = self._format_final_report(sections, structure, query)
 
         return report
 
-    def _determine_report_structure(
-        self, findings: Dict, query: str
-    ) -> List[Dict]:
-        
+    def _determine_report_structure(self, findings: Dict, query: str) -> List[Dict]:
         """Analyze content and determine optimal report structure."""
         combined_content = findings["current_knowledge"]
         prompt = f"""
@@ -92,44 +117,51 @@ class IntegratedReportGenerator:
     ) -> Dict[str, str]:
         """Research and generate content for each section in one step."""
         sections = {}
-        
+
         for section in structure:
             print(f"Processing section: {section['name']}")
             section_content = []
             section_content.append(f"# {section['name']}\n")
-            
+
             # Process each subsection by directly researching it
             for subsection in section["subsections"]:
                 # Add subsection header
                 section_content.append(f"## {subsection['name']}\n")
                 section_content.append(f"_{subsection['purpose']}_\n\n")
-                
+
                 # Generate a specific search query for this subsection
                 subsection_query = f"{query} {section['name']} {subsection['name']} {subsection['purpose']}"
-                
-                print(f"Researching subsection: {subsection['name']} with query: {subsection_query}")
-                
+
+                print(
+                    f"Researching subsection: {subsection['name']} with query: {subsection_query}"
+                )
+
                 # Configure search system for focused search
                 original_max_iterations = self.search_system.max_iterations
                 self.search_system.max_iterations = 1  # Keep search focused
-                
+
                 # Perform search for this subsection
                 subsection_results = self.search_system.analyze_topic(subsection_query)
-                
+
                 # Restore original iterations setting
                 self.search_system.max_iterations = original_max_iterations
-                
+
                 # Add the researched content for this subsection
-                if "current_knowledge" in subsection_results and subsection_results["current_knowledge"]:
+                if (
+                    "current_knowledge" in subsection_results
+                    and subsection_results["current_knowledge"]
+                ):
                     section_content.append(subsection_results["current_knowledge"])
                 else:
-                    section_content.append("*Limited information was found for this subsection.*\n")
-                
+                    section_content.append(
+                        "*Limited information was found for this subsection.*\n"
+                    )
+
                 section_content.append("\n\n")
-            
+
             # Combine all content for this section
             sections[section["name"]] = "\n".join(section_content)
-            
+
         return sections
 
     def _generate_sections(
@@ -157,15 +189,21 @@ class IntegratedReportGenerator:
         for i, section in enumerate(structure, 1):
             toc.append(f"{i}. **{section['name']}**")
             for j, subsection in enumerate(section["subsections"], 1):
-                toc.append(f"   {i}.{j} {subsection['name']} | _{subsection['purpose']}_")
+                toc.append(
+                    f"   {i}.{j} {subsection['name']} | _{subsection['purpose']}_"
+                )
 
         # Combine TOC and sections
         report_parts = ["\n".join(toc), ""]
-        
+
         # Add a summary of the research
         report_parts.append("# Research Summary")
-        report_parts.append(f"This report was researched using an advanced search system.")
-        report_parts.append(f"Research included targeted searches for each section and subsection.")
+        report_parts.append(
+            "This report was researched using an advanced search system."
+        )
+        report_parts.append(
+            "Research included targeted searches for each section and subsection."
+        )
         report_parts.append("\n---\n")
 
         # Add each section's content
@@ -173,30 +211,34 @@ class IntegratedReportGenerator:
             if section["name"] in sections:
                 report_parts.append(sections[section["name"]])
                 report_parts.append("")
-                
+
         # Format links from search system
-        formatted_all_links = utilties.search_utilities.format_links(links=self.search_system.all_links_of_system)
-        
+        # Get utilities module dynamically to avoid circular imports
+        utilities = importlib.import_module("local_deep_research.utilities")
+        formatted_all_links = utilities.search_utilities.format_links_to_markdown(
+            all_links=self.search_system.all_links_of_system
+        )
+
         # Create final report with all parts
         final_report_content = "\n\n".join(report_parts)
-        final_report_content = final_report_content + "\n\n## Sources\n\n" + formatted_all_links
-        
+        final_report_content = (
+            final_report_content + "\n\n## Sources\n\n" + formatted_all_links
+        )
+
         # Create metadata dictionary
         from datetime import datetime
+
         metadata = {
             "generated_at": datetime.utcnow().isoformat(),
             "initial_sources": len(self.search_system.all_links_of_system),
             "sections_researched": len(structure),
             "searches_per_section": self.searches_per_section,
-            "query": query
+            "query": query,
         }
-        
+
         # Return both content and metadata
-        return {
-            "content": final_report_content,
-            "metadata": metadata
-        }
+        return {"content": final_report_content, "metadata": metadata}
 
     def _generate_error_report(self, query: str, error_msg: str) -> str:
         error_report = f"=== ERROR REPORT ===\nQuery: {query}\nError: {error_msg}"
-        return error_report
+        return error_report