Update app.py

app.py

@@ -1,125 +1,95 @@
 import os
-import random
 import logging
-from datetime import datetime, timedelta
-from pathlib import Path
-import asyncio
 import requests
 import gradio as gr
+from sentence_transformers import SentenceTransformer, util
 from dotenv import load_dotenv
 
 # Load environment variables
 load_dotenv()
 
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[logging.FileHandler("app.log"), logging.StreamHandler()],
-)
-logger = logging.getLogger("DashboardBot")
-
-# Proxy Manager
-class ProxyManager:
-    def __init__(self, proxy_list=None):
-        self.proxy_list = proxy_list or []
-        self.current_proxy = None
-        self.last_rotation = datetime.now()
-        self.rotation_interval = timedelta(minutes=30)
-
-    def rotate(self):
-        if not self.proxy_list:
-            return None
-        self.current_proxy = random.choice(self.proxy_list)
-        self.last_rotation = datetime.now()
-        return {"http": self.current_proxy, "https": self.current_proxy}
-
-proxy_manager = ProxyManager(proxy_list=os.getenv("PROXY_LIST", "").split(","))
-
-# Content Generator
-class ContentGenerator:
-    def __init__(self, api_key):
-        self.api_key = api_key
-
-    async def generate_content(self, topic, audience, tone):
-        proxy = proxy_manager.rotate()
-        prompt = (
-            f"Generate 3 engaging content ideas for '{topic}'. "
-            f"Audience: {audience}, Tone: {tone}."
-        )
-        try:
-            response = requests.post(
-                "https://openrouter.ai/api/v1/chat/completions",
-                headers={"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"},
-                json={
-                    "model": "openai/gpt-4o-2024-11-20",
-                    "messages": [{"role": "user", "content": prompt}],
-                    "max_tokens": 1500,
-                },
-                proxies=proxy,
-                timeout=30,
-            )
-            response.raise_for_status()
-            data = response.json()
-            return data["choices"][0]["message"]["content"]
-        except Exception as e:
-            logger.error(f"Error generating content: {e}")
-            return "Error generating content."
-
-content_generator = ContentGenerator(api_key=os.getenv("OPENROUTER_API_KEY"))
-
-# Zapier Integration
-class ZapierIntegration:
-    def __init__(self, webhook_url):
-        self.webhook_url = webhook_url
-
-    async def notify_zapier(self, content):
-        try:
-            payload = {"content": content, "timestamp": datetime.now().isoformat()}
-            response = requests.post(self.webhook_url, json=payload, timeout=10)
-            response.raise_for_status()
-            return {"status": "success", "message": "Notified Zapier"}
-        except Exception as e:
-            logger.error(f"Error notifying Zapier: {e}")
-            return {"status": "error", "message": str(e)}
-
-zapier = ZapierIntegration(webhook_url=os.getenv("ZAPIER_WEBHOOK_URL"))
-
-# Gradio Interface
-def create_dashboard():
-    with gr.Blocks(title="Integrated Dashboard Bot") as dashboard:
-        gr.Markdown("# Content Automation Dashboard")
-
-        # Content Generation
-        topic = gr.Textbox(label="Content Topic", placeholder="Enter topic")
-        audience = gr.Dropdown(
-            label="Audience", choices=["General", "Professional", "Youth"], value="General"
-        )
-        tone = gr.Dropdown(
-            label="Tone", choices=["Casual", "Professional", "Luxury"], value="Professional"
-        )
-        generate_btn = gr.Button("Generate Content")
-        content_output = gr.Textbox(label="Generated Content", interactive=False)
-
-        # Zapier
-        zapier_btn = gr.Button("Send to Zapier")
-        zapier_status = gr.Textbox(label="Zapier Status", interactive=False)
-
-        async def handle_generate(topic, audience, tone):
-            return await content_generator.generate_content(topic, audience, tone)
-
-        async def handle_zapier(content):
-            if not content:
-                return "No content to send to Zapier."
-            result = await zapier.notify_zapier(content)
-            return result["message"]
-
-        generate_btn.click(handle_generate, inputs=[topic, audience, tone], outputs=content_output)
-        zapier_btn.click(handle_zapier, inputs=[content_output], outputs=zapier_status)
-
-    return dashboard
-
-
-if __name__ == "__main__":
-    dashboard = create_dashboard()
-    dashboard.launch(server_name="0.0.0.0", server_port=7860, share=True)
+# Logging configuration
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(message)s")
+
+# HuggingFace model for semantic similarity
+model = SentenceTransformer("all-MiniLM-L6-v2")
+
+# API Keys and Webhook URLs
+PHANTOMBUSTER_API_KEY = os.getenv("PHANTOMBUSTER_API_KEY")
+PHANTOMBUSTER_AGENT_ID = os.getenv("PHANTOMBUSTER_AGENT_ID")
+MAKE_WEBHOOK_URL = os.getenv("MAKE_WEBHOOK_URL")
+
+# Functions
+def fetch_phantombuster_data():
+    """Fetch hashtags from PhantomBuster output."""
+    url = f"https://phantombuster.com/api/v2/agents/{PHANTOMBUSTER_AGENT_ID}/output"
+    headers = {"X-Phantombuster-Key-1": PHANTOMBUSTER_API_KEY}
+    try:
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()
+        data = response.json()
+        hashtags = []
+        for post in data.get("data", []):
+            if "caption" in post:
+                hashtags.extend([tag for tag in post["caption"].split() if tag.startswith("#")])
+        return list(set(hashtags))  # Remove duplicates
+    except Exception as e:
+        logging.error(f"Error fetching PhantomBuster data: {e}")
+        return ["Error fetching hashtags."]
+
+def filter_relevant_hashtags(hashtags, keywords):
+    """Filter hashtags based on semantic relevance."""
+    hashtags_embeddings = model.encode(hashtags, convert_to_tensor=True)
+    keywords_embedding = model.encode(keywords, convert_to_tensor=True)
+    cosine_scores = util.pytorch_cos_sim(hashtags_embeddings, keywords_embedding)
+    relevant = [
+        hashtags[i]
+        for i in range(len(hashtags))
+        if cosine_scores[i].max() > 0.5
+    ]
+    return relevant
+
+def send_to_make_webhook(payload):
+    """Send data to Make.com webhook."""
+    try:
+        response = requests.post(MAKE_WEBHOOK_URL, json=payload, timeout=10)
+        response.raise_for_status()
+        return "Data sent successfully to Make.com!"
+    except Exception as e:
+        logging.error(f"Error sending to Make.com: {e}")
+        return "Error sending data to Make.com."
+
+# Gradio Dashboard
+with gr.Blocks() as dashboard:
+    gr.Markdown("# Instagram Hashtag Monitoring Dashboard")
+    
+    # Hashtag Extraction
+    competitor_username = gr.Textbox(label="Competitor Username", placeholder="e.g., competitor1")
+    extract_btn = gr.Button("Extract Hashtags")
+    extracted_hashtags = gr.Textbox(label="Extracted Hashtags", interactive=False)
+
+    # Hashtag Filtering
+    niche_keywords = gr.Textbox(label="Niche Keywords", placeholder="e.g., sustainability, eco-friendly")
+    filter_btn = gr.Button("Filter Relevant Hashtags")
+    relevant_hashtags = gr.Textbox(label="Relevant Hashtags", interactive=False)
+
+    # Send to Make.com
+    send_btn = gr.Button("Send to Make.com")
+    make_status = gr.Textbox(label="Webhook Status", interactive=False)
+
+    # Handlers
+    def handle_extract(username):
+        return fetch_phantombuster_data()
+
+    def handle_filter(hashtags, keywords):
+        return filter_relevant_hashtags(hashtags.split(","), keywords.split(","))
+
+    def handle_send_to_make(hashtags):
+        payload = {"hashtags": hashtags.split(","), "action": "monitor"}
+        return send_to_make_webhook(payload)
+
+    extract_btn.click(handle_extract, inputs=[competitor_username], outputs=[extracted_hashtags])
+    filter_btn.click(handle_filter, inputs=[extracted_hashtags, niche_keywords], outputs=[relevant_hashtags])
+    send_btn.click(handle_send_to_make, inputs=[relevant_hashtags], outputs=[make_status])
+
+dashboard.launch(server_name="0.0.0.0", server_port=7860, share=True)