fix: clean code and fix some erratas

Author: Pablo Ramos

app.py

@@ -1,21 +1,30 @@
 #!/usr/bin/env python3
 """
-Entry point for the PopulPy Streamlit application.
-This file serves as the entry point that users should run with 'streamlit run app.py'
+PopulPy - Entry point for Streamlit application
+
+This file serves as the main entry point to run the Streamlit application.
+It ensures that Python can correctly import modules from the project.
 """
 import os
 import sys
-from dotenv import load_dotenv
-
-# Make sure the current directory is in the path
-sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
-
-# Load environment variables
-load_dotenv()
+import subprocess
 
-# Import and run the main UI
-from src.ui.streamlit_app import main
+def main():
+    """
+    Run the Streamlit application with the correct Python path configuration
+    """
+    # Get absolute path to the project root directory
+    project_root = os.path.abspath(os.path.dirname(__file__))
+    
+    # Get path to the actual Streamlit app
+    streamlit_app_path = os.path.join(project_root, "src", "ui", "streamlit_app.py")
+    
+    # Set PYTHONPATH environment variable to include the project root
+    env = os.environ.copy()
+    env["PYTHONPATH"] = f"{project_root}:{env.get('PYTHONPATH', '')}"
+    
+    # Run the Streamlit app with proper environment
+    subprocess.run(["streamlit", "run", streamlit_app_path], env=env)
 
-# This will be executed when Streamlit runs this file
 if __name__ == "__main__":
     main()

example.env

@@ -1,12 +1,19 @@
 # PopulPy Environment Variables
-# Replace these values with your actual API keys
+# --------------------------------
+# Rename this file to '.env' and fill in your API keys
+# --------------------------------
 
-# Google API credentials
-GOOGLE_API_KEY=YOUR_GOOGLE_API_KEY
-SEARCH_ENGINE_ID=YOUR_SEARCH_ENGINE_ID
+# Google Custom Search API key
+# Get it from: https://developers.google.com/custom-search/v1/overview
+GOOGLE_API_KEY=your_google_api_key_here
 
-# Bing API credentials
-BING_API_KEY=YOUR_BING_API_KEY
+# Google Custom Search Engine ID
+# Create one at: https://programmablesearchengine.google.com/
+SEARCH_ENGINE_ID=your_search_engine_id_here
 
-# Database settings (optional)
-# DATABASE_PATH=sqlite:///your_custom_path.db
+# Bing Search API key (optional)
+# Get it from: https://www.microsoft.com/en-us/bing/apis/bing-web-search-api
+BING_API_KEY=your_bing_api_key_here
+
+# Optional: Database path (defaults to searches.db in the root folder)
+# DATABASE_PATH=path/to/your/database.db

main.py

@@ -1,53 +1,142 @@
+#!/usr/bin/env python3
+"""
+PopulPy - Command Line Interface
+Use this module to access PopulPy features from the command line
+"""
 import argparse
 import logging
 import os
 import csv
+import sys
+from typing import Dict, List, Any, Optional
+
+# Add the project root to the Python path
+sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
+
 from dotenv import load_dotenv
-from pytrends.request import TrendReq
 
-from src.services.google_service import (
-    get_top_results_for_related_searches,
-    create_wordcloud
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
 )
-
 logger = logging.getLogger(__name__)
 
+try:
+    from pytrends.request import TrendReq
+    from src.services.google_service import (
+        get_top_results_for_related_searches,
+        create_wordcloud,
+        get_google_search_trends,
+        get_google_related_searches
+    )
+except ImportError as e:
+    logger.error(f"Required package not found: {e}")
+    logger.error("Please install required packages using: pip install -r requirements.txt")
+    sys.exit(1)
+
 def parse_args():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-q", "--query", help="Query to search on Google", required=True)
-    parser.add_argument("-c", "--country", help="Country to search in", default="es")
-    parser.add_argument("-w", "--wordcloud", help="Path to save the wordcloud image")
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="PopulPy - Analyze search trends across multiple providers"
+    )
+    parser.add_argument("-q", "--query", 
+                      help="Query to search on Google", 
+                      required=True)
+    parser.add_argument("-c", "--country", 
+                      help="Country code to search in (e.g., ES, US)", 
+                      default="ES")
+    parser.add_argument("-t", "--timeframe", 
+                      help="Timeframe for trend analysis (e.g., 'today 5-y')", 
+                      default="today 5-y")
+    parser.add_argument("-w", "--wordcloud", 
+                      help="Path to save the wordcloud image", 
+                      default="wordcloud.png")
+    parser.add_argument("-o", "--output",
+                      help="Output file path for related searches data",
+                      default=None)
+    parser.add_argument("--no-wordcloud", 
+                      help="Skip generating wordcloud", 
+                      action="store_true")
     return parser.parse_args()
 
-def save_related_searches_to_csv(related_searches, filename):
-    with open(filename, mode='w', newline='', encoding='utf-8') as csv_file:
-        fieldnames = ['Related Search', 'Result 1', 'Result 2', 'Result 3', 'Result 4', 'Result 5']
-        writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
-        writer.writeheader()
-        for search, results in related_searches.items():
-            row = {'Related Search': search}
-            for i, result in enumerate(results, 1):
-                row[f"Result {i}"] = result
-            writer.writerow(row)
-
-if __name__ == "__main__":
+def save_related_searches_to_csv(related_searches: Dict[str, List[str]], 
+                               filename: str) -> None:
+    """
+    Save related searches and their results to a CSV file.
+    
+    Args:
+        related_searches: Dictionary with related searches and their results
+        filename: Path to save the CSV file
+    """
+    try:
+        with open(filename, mode='w', newline='', encoding='utf-8') as csv_file:
+            fieldnames = ['Related Search', 'Result 1', 'Result 2', 'Result 3', 'Result 4', 'Result 5']
+            writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
+            writer.writeheader()
+            
+            for search, results in related_searches.items():
+                row = {'Related Search': search}
+                for i, result in enumerate(results, 1):
+                    if i <= 5:  # Ensure we don't go beyond our fieldnames
+                        row[f"Result {i}"] = result
+                writer.writerow(row)
+                
+        logger.info(f"Results saved to {filename}")
+    except IOError as e:
+        logger.error(f"Error saving results to {filename}: {e}")
+        
+def main() -> None:
+    """Main entry point for the CLI application."""
     args = parse_args()
     load_dotenv()
-    pytrends = TrendReq()
+    
+    # Verify required environment variables
+    api_key = os.getenv("GOOGLE_API_KEY")
+    cx_id = os.getenv("SEARCH_ENGINE_ID")
+    
+    if not api_key or not cx_id:
+        logger.error("Missing required environment variables. Please set GOOGLE_API_KEY and SEARCH_ENGINE_ID.")
+        sys.exit(1)
 
     try:
+        # Initialize PyTrends
+        logger.info(f"Initializing PyTrends for query '{args.query}' in {args.country}")
+        pytrends = TrendReq(hl=args.country.lower())
+        pytrends.build_payload([args.query], timeframe=args.timeframe, geo=args.country)
+        
+        # Get related searches
+        logger.info("Getting related searches...")
+        related_searches = get_google_related_searches(args.query, pytrends)
+        
+        if not related_searches:
+            logger.warning("No related searches found")
+            return
+            
+        # Get search results for related searches
+        logger.info("Getting search results for related searches...")
         related_searches_with_results = get_top_results_for_related_searches(
-            args.query, 
-            pytrends, 
-            os.getenv("GOOGLE_API_KEY"), 
-            os.getenv("SEARCH_ENGINE_ID")
+            args.query, pytrends, api_key, cx_id
         )
 
-        save_related_searches_to_csv(related_searches_with_results, f"{args.query}_related_searches.csv")
+        # Save results to CSV if requested
+        output_file = args.output or f"{args.query.replace(' ', '_')}_related_searches.csv"
+        save_related_searches_to_csv(related_searches_with_results, output_file)
 
-        if args.wordcloud:
-            related_searches = list(related_searches_with_results.keys())
+        # Create wordcloud if requested
+        if not args.no_wordcloud:
+            logger.info(f"Creating wordcloud at {args.wordcloud}...")
             create_wordcloud(related_searches, args.wordcloud)
-            
+            logger.info(f"Wordcloud saved to {args.wordcloud}")
+        
+        logger.info("Analysis complete!")
+        
+    except KeyboardInterrupt:
+        logger.info("Operation canceled by user.")
+        sys.exit(0)
     except Exception as e:
-        logger.error(f"Error durante la ejecución: {str(e)}")
+        logger.error(f"Error during execution: {str(e)}", exc_info=True)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

models.py

@@ -1,67 +1,8 @@
-from sqlalchemy import create_engine, Column, Integer, String, DateTime, JSON
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
-from datetime import datetime
-
-Base = declarative_base()
-
-class Search(Base):
-    __tablename__ = 'searches'
-
-    id = Column(Integer, primary_key=True)
-    query = Column(String)
-    country = Column(String)
-    timestamp = Column(DateTime, default=datetime.now)
-    related_searches = Column(JSON)
-    settings = Column(JSON)
-
-    @classmethod
-    def create_tables(cls, engine):
-        Base.metadata.create_all(engine)
-
-class SearchManager:
-    def __init__(self, db_path='sqlite:///searches.db'):
-        self.engine = create_engine(db_path)
-        Search.create_tables(self.engine)
-        self.Session = sessionmaker(bind=self.engine)
-
-    def save_search(self, query, country, related_searches, settings):
-        session = self.Session()
-        try:
-            search = Search(
-                query=query,
-                country=country,
-                related_searches=related_searches,
-                settings=settings
-            )
-            session.add(search)
-            session.commit()
-            return search
-        finally:
-            session.close()
-
-    def get_recent_searches(self, limit=10):
-        session = self.Session()
-        try:
-            return session.query(Search).order_by(Search.timestamp.desc()).limit(limit).all()
-        finally:
-            session.close()
-
-    def get_search_by_id(self, search_id):
-        session = self.Session()
-        try:
-            return session.query(Search).filter(Search.id == search_id).first()
-        finally:
-            session.close()
-
-    def delete_search(self, search_id):
-        session = self.Session()
-        try:
-            search = session.query(Search).filter(Search.id == search_id).first()
-            if search:
-                session.delete(search)
-                session.commit()
-                return True
-            return False
-        finally:
-            session.close()
+"""
+Models module that re-exports the models from src/models/search.py
+This file exists for backward compatibility.
+"""
+from src.models.search import Search, SearchManager
+
+# Re-export the models
+__all__ = ['Search', 'SearchManager']