Update app2.py

app2.py

@@ -19,7 +19,8 @@ import validators
 from bs4 import BeautifulSoup
 
 # Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 # Configuration
@@ -37,6 +38,7 @@ history = []
 # Database setup
 Base = declarative_base()
 
+
 class Article(Base):
     __tablename__ = 'articles'
     id = Column(Integer, primary_key=True)
@@ -46,6 +48,7 @@ class Article(Base):
     hash = Column(String(32))
     timestamp = Column(DateTime, default=datetime.datetime.utcnow)
 
+
 async def create_db_engine(db_url):
     try:
         engine = create_engine(db_url)
@@ -54,17 +57,23 @@ async def create_db_engine(db_url):
     except SQLAlchemyError as e:
         logger.error(f"Database error: {e}")
         raise
+
+
 def sanitize_url(url: str) -> str:
     return url if validators.url(url) else None
 
-async def fetch_url_content(url: str, session: aiohttp.ClientSession) -> Tuple[str, str]:
+
+async def fetch_url_content(url: str,
+                            session: aiohttp.ClientSession) -> Tuple[str, str]:
     async with session.get(url) as response:
         content = await response.text()
         soup = BeautifulSoup(content, 'html.parser')
         title = soup.title.string if soup.title else "No Title"
         return title, content
 
-async def save_to_database(session, url: str, title: str, content: str, hash: str):
+
+async def save_to_database(session, url: str, title: str, content: str,
+                           hash: str):
     try:
         article = Article(url=url, title=title, content=content, hash=hash)
         session.add(article)
@@ -73,18 +82,24 @@ async def save_to_database(session, url: str, title: str, content: str, hash: st
         logger.error(f"Database error: {e}")
         await session.rollback()
 
-async def save_to_csv(storage_location: str, url: str, title: str, content: str, timestamp: datetime.datetime):
+
+async def save_to_csv(storage_location: str, url: str, title: str,
+                    content: str, timestamp: datetime.datetime):
     try:
         os.makedirs(os.path.dirname(storage_location), exist_ok=True)
         with open(storage_location, "a", newline='', encoding="utf-8") as csvfile:
             csv_writer = csv.writer(csvfile)
-            csv_writer.writerow([timestamp.strftime("%Y-%m-%d %H:%M:%S"), url, title, content])
+            csv_writer.writerow([
+                timestamp.strftime("%Y-%m-%d %H:%M:%S"), url, title, content
+            ])
     except IOError as e:
         logger.error(f"IOError saving to CSV: {e}")
     except Exception as e:
         logger.error(f"Unexpected error saving to CSV: {e}")
 
-async def monitor_url(url: str, interval: int, storage_location: str, feed_rss: bool, db_session):
+
+async def monitor_url(url: str, interval: int, storage_location: str,
+                      feed_rss: bool, db_session):
     previous_hash = ""
     async with aiohttp.ClientSession() as session:
         while True:
@@ -98,14 +113,19 @@ async def monitor_url(url: str, interval: int, storage_location: str, feed_rss:
 
                     if feed_rss:
                         try:
-                            await save_to_database(db_session, url, title, content, current_hash)
+                            await save_to_database(db_session, url, title,
+                                                   content, current_hash)
                         except SQLAlchemyError as e:
-                            logger.error(f"Database error while saving {url}: {e}")
+                            logger.error(
+                                f"Database error while saving {url}: {e}")
 
                     if storage_location:
-                        await save_to_csv(storage_location, url, title, content, timestamp)
+                        await save_to_csv(storage_location, url, title,
+                                        content, timestamp)
 
-                    history.append(f"Change detected at {url} on {timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
+                    history.append(
+                        f"Change detected at {url} on {timestamp.strftime('%Y-%m-%d %H:%M:%S')}"
+                    )
                     logger.info(f"Change detected at {url}")
 
                     change_counts[url] = change_counts.get(url, 0) + 1
@@ -125,23 +145,29 @@ async def monitor_url(url: str, interval: int, storage_location: str, feed_rss:
 
             await asyncio.sleep(interval)
 
-async def start_monitoring(urls: List[str], storage_location: str, feed_rss: bool):
+
+async def start_monitoring(urls: List[str], storage_location: str,
+                          feed_rss: bool):
     global db_session
     for url in urls:
         if url not in monitoring_tasks:
             sanitized_url = sanitize_url(url)
             if sanitized_url:
-                task = asyncio.create_task(monitor_url(sanitized_url, DEFAULT_MONITORING_INTERVAL, storage_location, feed_rss, db_session))
+                task = asyncio.create_task(
+                    monitor_url(sanitized_url, DEFAULT_MONITORING_INTERVAL,
+                                storage_location, feed_rss, db_session))
                 monitoring_tasks[sanitized_url] = task
             else:
                 logger.warning(f"Invalid URL: {url}")
                 history.append(f"Invalid URL: {url}")
     return "Monitoring started"
 
+
 async def cleanup_resources(url: str):
     # Add any cleanup logic here, e.g., closing database connections
     pass
 
+
 def stop_monitoring(url: str):
     if url in monitoring_tasks:
         monitoring_tasks[url].cancel()
@@ -149,11 +175,6 @@ def stop_monitoring(url: str):
         del monitoring_tasks[url]
     return "Monitoring stopped"
 
-async def on_start_click(target_urls_str: str, storage_loc: str, feed_enabled: bool):
-    urls = [url.strip() for url in target_urls_str.split(",")]  # Split the input by commas
-    result = await start_monitoring(urls, storage_loc if storage_loc else None, feed_enabled)
-    return result
-
 
 def generate_rss_feed():
     session = Session()
@@ -178,9 +199,11 @@ def generate_rss_feed():
     finally:
         session.close()
 
+
 async def chatbot_response(message: str, history: List[Tuple[str, str]]):
     try:
-        client = InferenceClient("mistralai/Mixtral-8x7B-Instruct-v0.1", token=HUGGINGFACE_API_KEY)
+        client = InferenceClient("mistralai/Mixtral-8x7B-Instruct-v0.1",
+                                 token=HUGGINGFACE_API_KEY)
         response = await client.text_generation(message, max_new_tokens=100)
 
         history.append((message, response[0]['generated_text']))
@@ -188,9 +211,11 @@ async def chatbot_response(message: str, history: List[Tuple[str, str]]):
         return history, history
     except Exception as e:
         logger.error(f"Chatbot error: {e}")
-        history.append((message, "Error: Could not get a response from the chatbot."))
+        history.append((message,
+                        "Error: Could not get a response from the chatbot."))
         return history, history
 
+
 async def update_db_status(db_status):
     while True:
         try:
@@ -200,10 +225,12 @@ async def update_db_status(db_status):
             await db_status.update(value="Disconnected")
         await asyncio.sleep(60)  # Check every minute
 
+
 async def update_feed_content(db_session):
     try:
-        articles = await db_session.       query(Article).order_by(Article.timestamp.desc()).limit(20).all()
-        feed = {
+        articles = await db_session.query(Article).order_by(
+            Article.timestamp.desc()).limit(20).all()
+        feed        {
             'title': 'Website Changes Feed',
             'link': 'http://yourwebsite.com/feed',
             'description': 'Feed of changes detected on monitored websites.',
@@ -224,10 +251,11 @@ async def periodic_update_with_error_handling(db_session):
     while True:
         try:
             await asyncio.sleep(300)  # Wait for 5 minutes
-            await update_feed_content(db_session)  # Pass db_session here
+            await update_feed_content(db_session)
         except Exception as e:
             logger.error(f"Error in periodic update: {e}")
 
+
 async def main():
     global db_session
     try:
@@ -303,4 +331,5 @@ async def main():
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())
+