Upload 2 files

app.py

@@ -0,0 +1,335 @@
+import gradio as gr
+import google.generativeai as genai
+from bs4 import BeautifulSoup, NavigableString
+import re
+import json
+import random
+import os
+
+# --- Constants & Config ---
+BLACKLIST_WORDS = [
+    "landscape", "realm", "navigate", "unveil", "explore", "transformative",
+    "encompass", "examine", "crucial", "discover", "dive", "delve",
+    "uncover", "unlock", "elevate", "unleash", "harness"
+]
+
+BRITISH_MAPPINGS = {
+    "color": "colour", "flavor": "flavour", "humor": "humour", "labor": "labour",
+    "neighbor": "neighbour", "favor": "favour", "honor": "honour", "behavior": "behaviour",
+    "center": "centre", "fiber": "fibre", "liter": "litre", "theater": "theatre",
+    "meter": "metre", "analyze": "analyse", "breathalyze": "breathalyse", "paralyze": "paralyse",
+    "catalyze": "catalyse", "organization": "organisation", "realize": "realise",
+    "recognize": "recognise", "standardize": "standardise", "appetizer": "appetiser",
+    "leukemia": "leukaemia", "maneuver": "manoeuvre", "estrogen": "oestrogen",
+    "pediatric": "paediatric", "defense": "defence", "license": "licence",
+    "offense": "offence", "pretense": "pretence", "traveler": "traveller", "modeling": "modelling",
+    "cancelled": "cancelled",
+    "program": "programme",
+}
+
+SOCIAL_PROOF_TEMPLATES = [
+    "We recently hired {KEYWORD} for our project, and the results were outstanding. The team was professional, efficient, and delivered exactly what we needed. I highly recommend their services to anyone looking for reliable {KEYWORD_LOWER}.",
+    "I was struggling to find trustworthy {KEYWORD_LOWER} until I found this company. They exceeded my expectations with their attention to detail and timely completion. It was a refreshing experience to work with such dedicated professionals.",
+    "If you need {KEYWORD_LOWER}, look no further. Their expertise is evident in the quality of their work, and the customer service is top-notch. I am completely satisfied with the outcome and will definitely use them again.",
+    "Finding a dependable {KEYWORD} can be difficult, but this team made it easy. They communicated clearly throughout the process and finished the job to a high standard. I'm very impressed with their workmanship."
+]
+
+# --- Logic Ports ---
+
+def capitalize(s):
+    if not s: return ""
+    return s[0].upper() + s[1:]
+
+def parse_growmatic_data(text):
+    term_map = {}
+    if not text: return term_map
+    # Regex to match: "term": number% OR term: number%
+    regex = r'["\']?([\w\s]+)["\']?\s*[:=]\s*(\d+)%?'
+    matches = re.findall(regex, text)
+    for term, score in matches:
+        term_lower = term.strip().lower()
+        if term_lower:
+            term_map[term_lower] = int(score)
+    return term_map
+
+def generate_titles(main_keyword, term_map):
+    titles = []
+    # Templates
+    templates = [
+        "{KEYWORD} in [location] - {TERM_A} [zip]",
+        "{KEYWORD} in [location] - {TERM_B} Services [zip]",
+        "Expert {KEYWORD} in [location] - {TERM_C} [zip]",
+        "{KEYWORD} Services in [location] - {TERM_A} [zip]",
+        "Leading {KEYWORD} in [location] - {TERM_B} [zip]",
+        "{KEYWORD} Specialists in [location] - {TERM_C} [zip]",
+        "Best {KEYWORD} in [location] - {TERM_A} Solutions [zip]"
+    ]
+
+    # Sort terms by score descending
+    sorted_terms = sorted(term_map.keys(), key=lambda k: term_map[k], reverse=True)
+    
+    term_a = sorted_terms[0] if len(sorted_terms) > 0 else "Projects"
+    term_b = sorted_terms[1] if len(sorted_terms) > 1 else "Installations"
+    term_c = sorted_terms[2] if len(sorted_terms) > 2 else "Solutions"
+
+    for tmpl in templates:
+        t = tmpl.replace("{KEYWORD}", main_keyword)
+        t = t.replace("{TERM_A}", capitalize(term_a))
+        t = t.replace("{TERM_B}", capitalize(term_b))
+        t = t.replace("{TERM_C}", capitalize(term_c))
+        titles.append(t)
+
+    # Variations
+    variations = [
+        f"{main_keyword} {capitalize(term_a)}",
+        f"{main_keyword} {capitalize(term_b)} Services",
+        f"{capitalize(term_a)} & {main_keyword}"
+    ]
+    return titles + variations
+
+def calculate_score(title, term_map):
+    title_lower = title.lower()
+    
+    # Blacklist check
+    for bad_word in BLACKLIST_WORDS:
+        if bad_word in title_lower:
+            return {"title": title, "score": 0, "terms": "BLACKLISTED"}
+
+    total_score = 0
+    matched_terms = []
+    
+    for term, weight in term_map.items():
+        if term in title_lower:
+            total_score += weight
+            matched_terms.append(f"{term} ({weight}%)")
+    
+    # Scale score (approx 0-10)
+    final_score = round(total_score / 30, 1)
+    if final_score > 10: final_score = 10
+    
+    return {
+        "title": title,
+        "score": final_score,
+        "terms": ", ".join(matched_terms)
+    }
+
+def process_text_nodes(html_content, callback):
+    if not html_content: return ""
+    soup = BeautifulSoup(html_content, 'html.parser')
+    
+    # Recursive function specifically for NavigableStrings
+    def walk(node):
+        if isinstance(node, NavigableString):
+            if node.parent.name not in ['script', 'style']: # Skip script/style tags
+                new_text = callback(str(node))
+                if new_text != str(node):
+                    node.replace_with(new_text)
+        elif hasattr(node, 'children'):
+             for child in node.children:
+                 walk(child)
+
+    walk(soup)
+    return str(soup)
+
+def convert_to_british(html_content):
+    if not html_content: return ""
+    
+    def replacer(text):
+        processed = text
+        for us, uk in BRITISH_MAPPINGS.items():
+            # Regex for whole word match, case insensitive
+            pattern = re.compile(r'\b' + re.escape(us) + r'\b', re.IGNORECASE)
+            
+            def match_handler(m):
+                # Preserve case
+                word = m.group(0)
+                if word[0].isupper():
+                    return capitalize(uk)
+                return uk
+                
+            processed = pattern.sub(match_handler, processed)
+        return processed
+
+    return process_text_nodes(html_content, replacer)
+
+def clean_homepage_content(html_content):
+    if not html_content: return ""
+    
+    def replacer(text):
+        clean = text
+        
+        # 1. Remove phrases
+        phrases_to_remove = [
+            r'\s+in\s+\[location\]', r'in\s+\[location\]',
+            r'\s+across\s+the\s+\[location\]', r'across\s+the\s+\[location\]',
+            r'\s+across\s+\[location\]', r'across\s+\[location\]',
+            r'\s+around\s+the\s+\[location\]', r'around\s+the\s+\[location\]',
+            r'\s+nearby\s+\[location\]', r'nearby\s+\[location\]',
+            r'\s+throughout\s+\[location\]', r'throughout\s+\[location\]'
+        ]
+        for phrase in phrases_to_remove:
+            clean = re.sub(phrase, '', clean, flags=re.IGNORECASE)
+
+        # 2. Remove tags
+        tags_to_remove = [
+            r'\[location\]', r'\[county\]', r'\[region\]', r'\[zip\]'
+        ]
+        for tag in tags_to_remove:
+            clean = re.sub(tag, '', clean, flags=re.IGNORECASE)
+
+        # 3. Footer text
+        footer_regex = r'in\s*\[region\]\.?\s*Here\s*are\s*some\s*towns\s*we\s*cover\s*near\s*\[location\]\s*\[zip\]\s*\[cities[^\]]*\]'
+        clean = re.sub(footer_regex, '', clean, flags=re.IGNORECASE | re.DOTALL)
+
+        # 4. Whitespace cleanup
+        clean = re.sub(r'\s{2,}', ' ', clean)
+        clean = re.sub(r'\s+\.', '.', clean)
+        clean = re.sub(r'\s+\?', '?', clean)
+        clean = re.sub(r'\s+\,', ',', clean)
+        
+        return clean.strip()
+
+    return process_text_nodes(html_content, replacer)
+
+
+# --- Gemini Integration ---
+
+def call_gemini(prompt, api_key, model_name="gemini-1.5-flash"):
+    if not api_key: return None
+    try:
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel(model_name)
+        response = model.generate_content(prompt)
+        return response.text
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# --- Main Automation Logic ---
+
+def run_automation(main_keyword, site_link, growmatic_data, api_key, article_content, model_selection):
+    if not main_keyword:
+        return "Error: Main Keyword is required.", ""
+
+    term_map = parse_growmatic_data(growmatic_data)
+    
+    # 1. Magic Page Logic
+    magic_output_html = ""
+    
+    # SEO Titles
+    if api_key:
+        # LLM Title Gen
+        terms_str = ", ".join([f"{k} ({v}%)" for k, v in term_map.items()])
+        prompt = f"""Act as an SEO expert. 
+        Main Keyword: "{main_keyword}"
+        Semantic Terms (Growmatic Data): {terms_str}
+
+        Task:
+        1. Generate 3 highly optimized Meta Titles for a page targeting "{main_keyword}". Use the semantic terms to increase relevance.
+        2. Generate a list of 5-8 Meta Keywords (comma separated).
+        3. Select the "Best" Title from the 3 options based on SEO scoring principles.
+
+        Output JSON format ONLY (no markdown):
+        {{
+            "metaTitles": ["Title 1", "Title 2", "Title 3"],
+            "bestTitle": "The Best Title",
+            "metaKeywords": "keyword1, keyword2, keyword3"
+        }}"""
+        
+        llm_resp = call_gemini(prompt, api_key, model_selection)
+        
+        try:
+            # Clean json block if present
+            clean_json = llm_resp.replace('```json', '').replace('```', '').strip()
+            data = json.loads(clean_json)
+            
+            magic_output_html += "<h3>--- GENERATED SEO TITLES (LLM) ---</h3>"
+            for t in data.get("metaTitles", []):
+                is_best = t == data.get("bestTitle")
+                style = "color: blue; font-weight: bold;" if is_best else ""
+                suffix = "(Best Match)" if is_best else ""
+                magic_output_html += f'<p style="{style}">• {t} {suffix}</p>'
+            
+            magic_output_html += f"<p><strong>Meta Keywords:</strong> {data.get('metaKeywords', '')}</p><br>"
+            
+        except:
+             magic_output_html += f"<p style='color:red'>Error parsing LLM response: {llm_resp}</p>"
+
+    else:
+        # Template Gen
+        titles = generate_titles(main_keyword, term_map)
+        scored = [calculate_score(t, term_map) for t in titles]
+        scored.sort(key=lambda x: x['score'], reverse=True)
+        
+        magic_output_html += "<h3>--- GENERATED SEO TITLES (Template) ---</h3>"
+        for item in scored[:5]:
+             magic_output_html += f"<p>• [Score: {item['score']}] {item['title']}</p>"
+        magic_output_html += "<br>"
+
+    # Social Proof
+    social_proof_text = ""
+    if api_key:
+        sp_prompt = f"""Write 2 positive testimonials for a service provider offering "{main_keyword}". 
+        Create two very non-generic names including last names. 
+        Each testimonial should be max 3-4 sentences. 
+        Focus on professionalism, result quality, and ease of working with them."""
+        social_proof_text = call_gemini(sp_prompt, api_key, model_selection)
+    else:
+         tmpl = random.choice(SOCIAL_PROOF_TEMPLATES)
+         social_proof_text = tmpl.replace("{KEYWORD}", main_keyword).replace("{KEYWORD_LOWER}", main_keyword.lower())
+
+    magic_output_html += f"<h3>--- MAGIC PAGE METADATA ---</h3>"
+    magic_output_html += f"<p><strong>Target Keyword:</strong> {main_keyword}</p>"
+    magic_output_html += f"<p><strong>Site URL:</strong> {site_link}</p><br>"
+    
+    magic_output_html += f"<h3>--- SOCIAL PROOF ---</h3>"
+    magic_output_html += f"<p>{social_proof_text.replace(chr(10), '<br>')}</p>"
+
+    # 2. Homepage Logic
+    clean_html = clean_homepage_content(article_content)
+    british_html = convert_to_british(clean_html)
+
+    return magic_output_html, british_html
+
+
+# --- Gradio UI ---
+
+with gr.Blocks(title="Content Automation Tool") as app:
+    gr.Markdown("# Content Automation Tool (Gradio Edition)")
+    gr.Markdown("Generate Magic Page & Optimized Homepage Content Instantly")
+    
+    with gr.Row():
+        with gr.Column():
+            main_keyword = gr.Textbox(label="Main Keyword", placeholder="e.g. Suspended Ceiling Contractors")
+            site_link = gr.Textbox(label="Site Link", placeholder="e.g. https://example.com")
+            growmatic_data = gr.TextArea(label="Growmatic Data", placeholder='"suspended": 100%, "ceiling": 73%')
+            
+            with gr.Row():
+                api_key = gr.Textbox(label="Gemini API Key", type="password", placeholder="AIza...")
+                model_selection = gr.Dropdown(
+                    choices=["gemini-1.5-flash", "gemini-1.5-pro", "gemini-1.0-pro"], 
+                    value="gemini-1.5-flash", 
+                    label="Gemini Model"
+                )
+            
+        with gr.Column():
+            article_content = gr.Textbox(label="Article Content (HTML/Text)", lines=15, placeholder="Paste content with [tags] here...")
+
+    generate_btn = gr.Button("Generate Output ✨", variant="primary")
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Magic Page Output")
+            magic_output = gr.HTML(label="Magic Page Result")
+        
+        with gr.Column():
+            gr.Markdown("### Homepage Output")
+            home_output = gr.HTML(label="Homepage Result")
+
+    generate_btn.click(
+        fn=run_automation,
+        inputs=[main_keyword, site_link, growmatic_data, api_key, article_content, model_selection],
+        outputs=[magic_output, home_output]
+    )
+
+if __name__ == "__main__":
+    app.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio
+beautifulsoup4
+google-generativeai