update new files

app.py

@@ -29,7 +29,6 @@ from server import (
 ui = ui.page_fluid(
     ui.page_navbar(
         blog.ui,
-        #general_blog.ui,
         meta.ui,
         threads.ui,
         twitter.ui,
@@ -45,7 +44,6 @@ ui = ui.page_fluid(
 
 def server(input, output, session):
     blog_srv.server(input, output, session)
-    #general_blog_srv.server(input, output, session)
     meta_srv.server(input, output, session)
     threads_srv.server(input, output, session)
     twitter_srv.server(input, output, session)

server/blog.py

@@ -72,8 +72,7 @@ async def get_keywords_and_content(url: str, top_n=5, llm_n=25):
             llm="gemini",
             md=False,
             temperature=0.6,
-            max_tokens=100,
-            model_name="gemini-2.0-flash-lite"
+            max_tokens=100
         )
         print(condensed_topic_raw)
 
@@ -89,6 +88,7 @@ async def get_keywords_and_content(url: str, top_n=5, llm_n=25):
         condensed_topic = ["trading cards"]
 
     # === Step 2: Pull suggestions from PyTrends ===
+    time.sleep(3)
     all_suggestions = set()
     try:
         pytrends = TrendReq(hl="en-US", tz=360, timeout=10)
@@ -149,6 +149,7 @@ async def get_keywords_and_content(url: str, top_n=5, llm_n=25):
         print(f"[INFO] Fallback keywords used: {filtered_keywords[:top_n]}")
 
     # === Step 5: Enforce minimum of 30 keywords ===
+    time.sleep(3)
     combined_keywords = list(dict.fromkeys(filtered_keywords))  # remove duplicates
     if len(combined_keywords) < 30:
         needed = 30 - len(combined_keywords)
@@ -203,8 +204,10 @@ def publish_blog_post(title: str, html_body: str, blog_id: str = BLOG_ID):
     }
     data = {
         "article": {
+            "author": "Ultima Supply Writer: (Bingus)",
             "title": title,
-            "body_html": html_body
+            "body_html": html_body,
+            
         }
     }
 
@@ -228,6 +231,7 @@ def server(input, output, session):
             return ui.HTML("<p><strong>⚠️ Please enter a URL.</strong></p>")
 
         keywords, scraped = await get_keywords_and_content(url)
+        time.sleep(3)
         related_keywords.set(keywords)
         keyword_str = ", ".join(keywords)
 
@@ -256,6 +260,7 @@ def server(input, output, session):
             f"- Use <h1> for the blog title\n"
             f"- Use <h2> for section headers\n"
             f"- Use <p> for all paragraphs\n"
+            f"- Avoid using all caps\n"
             f"- NO Markdown, NO triple backticks, NO code blocks, NO formatting fences\n"
             f"- DO NOT include any hyperlinks, URLs, web addresses, or references to any external sites or brands — no exceptions\n"
             f"- DO NOT include any <a> tags except for the final line below\n\n"

server/general_blog.py

@@ -1,319 +0,0 @@
-import os, sys, re, ast, time, requests
-from bs4 import BeautifulSoup
-from pytrends.request import TrendReq
-from shiny import ui, reactive, render
-from playwright.async_api import async_playwright
-from dotenv import load_dotenv
-
-# === LLM Connect ===
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "code")))
-from llm_connect import get_response
-
-load_dotenv()
-
-SHOPIFY_STORE = "ultima-supply.myshopify.com"
-SHOPIFY_TOKEN = os.getenv("SHOPIFY_TOKEN")
-SHOPIFY_API_VERSION = "2024-04"
-BLOG_ID = "73667707064"
-
-# === Static scraper for pokemon.com ===
-async def scrape_section_content_from_url(url: str) -> str:
-    try:
-        async with async_playwright() as p:
-            browser = await p.chromium.launch(headless=True)
-            page = await browser.new_page()
-            await page.goto(url, timeout=30000)
-            await page.wait_for_load_state("networkidle")
-            html = await page.content()
-            await browser.close()
-
-            soup = BeautifulSoup(html, "html.parser")
-            print(soup)
-
-            # Match all divs and extract text
-            content_blocks = soup.find_all("div")
-            if not content_blocks:
-                print("[WARN] No <div> elements found.")
-                return ""
-
-            texts = [div.get_text(separator=" ", strip=True) for div in content_blocks if div.get_text(strip=True)]
-            print(f"[INFO] Extracted {len(texts)} content blocks.")
-            return "\n\n".join(texts)
-
-    except Exception as e:
-        print(f"[ERROR] Scraping failed: {e}")
-        return ""
-
-
-
-# === Keyword generation + scraping ===
-async def get_keywords_and_content(url: str, top_n=5, llm_n=25):
-    scraped_text = scrape_section_content_from_url(url)
-    if not scraped_text:
-        print("[ERROR] No scraped content. Cannot proceed.")
-        return [], ""
-
-    # === Step 1: Extract condensed topic keywords ===
-    try:
-        condensed_prompt = (
-            "Extract exactly 5 to 7 Google search phrases from the content below that reflect real user search intent. "
-            "Each phrase should describe a specific product, use case, or collector topic — not generic brands or categories.\n\n"
-            "⚠️ Rules:\n"
-            "- Each phrase must be 2 to 5 words\n"
-            "- All phrases must be lowercase and ASCII-only\n"
-            "- Do NOT include apostrophes, single quotes, or quotation marks — rewrite or skip any phrases that contain them\n"
-            "- Do NOT include single words or overly broad terms like 'pokemon'\n"
-            "- Do NOT return line breaks, bullet points, or list formatting\n\n"
-            "✅ Output format:\n"
-            "Return a single comma-separated string of keyword phrases, with no brackets, no quotes, and no explanation.\n"
-            "Example output:\n"
-            "vintage charizard value, graded card pricing, rare booster packs, psa 10 umbreon, tcg price trends\n\n"
-            f"Content:\n{scraped_text}"
-        )
-
-
-        condensed_topic_raw = get_response(
-            input=condensed_prompt,
-            template=lambda x: x.strip(),
-            llm="gemini",
-            md=False,
-            temperature=0.6,
-            max_tokens=100,
-            model_name="gemini-2.0-flash-lite"
-        )
-        print(condensed_topic_raw)
-
-        # Parse comma-separated string
-        condensed_topic = [kw.strip() for kw in condensed_topic_raw.split(",") if kw.strip()]
-
-        if not condensed_topic:
-            condensed_topic = ["trading cards"]
-
-        print(f"[INFO] Condensed topic keywords: {condensed_topic}")
-    except Exception as e:
-        print(f"[WARN] Could not infer topics: {e}")
-        condensed_topic = ["trading cards"]
-
-    # === Step 2: Pull suggestions from PyTrends ===
-    all_suggestions = set()
-    try:
-        pytrends = TrendReq(hl="en-US", tz=360, timeout=10)
-        for topic in condensed_topic:
-            time.sleep(5)
-            suggestions = pytrends.suggestions(keyword=topic)
-            if suggestions:
-                titles = [s["title"] for s in suggestions]
-                all_suggestions.update(titles)
-                print(f"[INFO] Suggestions for '{topic}': {titles[:3]}")
-    except Exception as e:
-        print(f"[WARN] PyTrends suggestions failed: {e}")
-
-    all_suggestions = list(all_suggestions)
-
-    # === Step 3: Let Gemini filter suggestions for relevance ===
-    filtered_keywords = []
-    if all_suggestions:
-        filter_prompt = (
-            f"The following article was scraped:\n\n{scraped_text[:1500]}\n\n"
-            f"Here is a list of keyword suggestions:\n{all_suggestions}\n\n"
-            "Return only the keywords that are clearly relevant to the article topic. "
-            "Return a valid Python list of strings only. No explanation, bullets, or formatting."
-        )
-
-        raw_filtered = get_response(
-            input=filter_prompt,
-            template=lambda x: x.strip(),
-            llm="gemini",
-            md=False,
-            temperature=0.3,
-            max_tokens=200
-        )
-
-        match = re.search(r"\[.*?\]", raw_filtered)
-        if match:
-            try:
-                filtered_keywords = ast.literal_eval(match.group(0))
-            except:
-                filtered_keywords = []
-
-    # === Step 4: Fallback to Gemini keyword generation if needed ===
-    if not filtered_keywords:
-        fallback_prompt = (
-            f"You are an SEO expert. Generate {llm_n} niche-relevant SEO keywords "
-            f"based on this content:\n\n{scraped_text}\n\n"
-            "Return a comma-separated list of lowercase 2–5 word search phrases. No formatting."
-        )
-        fallback_keywords_raw = get_response(
-            input=fallback_prompt,
-            template=lambda x: x.strip(),
-            llm="gemini",
-            md=False,
-            temperature=0.7,
-            max_tokens=400
-        )
-        filtered_keywords = [kw.strip() for kw in fallback_keywords_raw.split(",") if kw.strip()]
-        print(f"[INFO] Fallback keywords used: {filtered_keywords[:top_n]}")
-
-    # === Step 5: Enforce minimum of 30 keywords ===
-    combined_keywords = list(dict.fromkeys(filtered_keywords))  # remove duplicates
-    if len(combined_keywords) < 30:
-        needed = 30 - len(combined_keywords)
-        print(f"[INFO] Need {needed} more keywords to reach 30. Using Gemini to pad.")
-
-        pad_prompt = (
-            f"The following article content is missing SEO keyword coverage:\n\n"
-            f"{scraped_text}\n\n"
-            f"Generate exactly {needed} additional SEO keyword phrases.\n"
-            "Each keyword must:\n"
-            "- be 2 to 5 words long\n"
-            "- be lowercase only\n"
-            "- use ASCII characters only (no symbols or accents)\n"
-            "- be clearly relevant to the article\n"
-            "- avoid generic terms like 'pokemon'\n\n"
-            "Return only the keywords as a single comma-separated string, with no extra formatting or explanation.\n"
-            "Example output:\n"
-            "keyword one, keyword two, keyword three"
-        )
-
-        pad_raw = get_response(
-            input=pad_prompt,
-            template=lambda x: x.strip(),
-            llm="gemini",
-            md=False,
-            temperature=0.7,
-            max_tokens=200
-        )
-
-        pad_keywords = []
-        print(pad_raw)
-
-        try:
-            pad_keywords = [kw.strip() for kw in pad_raw.split(",") if kw.strip()]
-        except Exception as e:
-            print(f"[WARN] Keyword parsing failed: {e}")
-            pad_keywords = []
-
-        combined_keywords = list(dict.fromkeys(combined_keywords + pad_keywords))
-        print(f"[INFO] Padded {len(pad_keywords)} keywords:", pad_keywords)
-
-        return combined_keywords[:30], scraped_text
-
-
-# === Shopify publisher ===
-def publish_blog_post(title: str, html_body: str, blog_id: str = BLOG_ID):
-    url = f"https://{SHOPIFY_STORE}/admin/api/{SHOPIFY_API_VERSION}/blogs/{blog_id}/articles.json"
-    headers = {
-        "X-Shopify-Access-Token": SHOPIFY_TOKEN,
-        "Content-Type": "application/json"
-    }
-    data = {
-        "article": {
-            "title": title,
-            "body_html": html_body
-        }
-    }
-
-    response = requests.post(url, json=data, headers=headers)
-    if response.status_code == 201:
-        return True, response.json()
-    else:
-        return False, response.text
-
-# === Shiny Server ===
-def server(input, output, session):
-    related_keywords = reactive.Value([])
-    generated_blog = reactive.Value(("", ""))  # (title, html_content)
-
-    @output
-    @render.ui
-    @reactive.event(input.blog_generate_btn)
-    async def blog_result_gen():
-        url = input.blog_url()
-        if not url:
-            return ui.HTML("<p><strong>⚠️ Please enter a URL.</strong></p>")
-
-        keywords, scraped = await get_keywords_and_content(url)
-        related_keywords.set(keywords)
-        keyword_str = ", ".join(keywords)
-
-        # Title generation from scraped text
-        infer_topic_prompt = (
-            f"Based on the following article content:\n\n{scraped[:2000]}\n\n"
-            f"Return a short, descriptive blog post title (max 70 characters)."
-            f"Return ONLY the TITLE"
-        )
-        seo_title = get_response(
-            input=infer_topic_prompt,
-            template=lambda x: x.strip().replace('"', ''),
-            llm="gemini",
-            md=False,
-            temperature=0.5,
-            max_tokens=20
-        )
-
-        # Blog generation with injected SEO
-        prompt = (
-            f"You are a content writer for a collectibles brand called 'Ultima Supply'.\n"
-            f"Given the following scraped content:\n\n{scraped}\n\n"
-            f"Rewrite this in an engaging, original, and heavily detailed SEO-optimized blog post.\n"
-            f"Naturally and organically integrate the following SEO keywords throughout the content:\n{keyword_str}\n\n"
-            f"⚠️ STRICT FORMATTING RULES (must be followed exactly):\n"
-            f"- Use <h1> for the blog title\n"
-            f"- Use <h2> for section headers\n"
-            f"- Use <p> for all paragraphs\n"
-            f"- NO Markdown, NO triple backticks, NO code blocks, NO formatting fences\n"
-            f"- DO NOT include any hyperlinks, URLs, web addresses, or references to any external sites or brands — no exceptions\n"
-            f"- DO NOT include any <a> tags except for the final line below\n\n"
-            f"✅ FINAL LINE ONLY:\n"
-            f"Add this exact call-to-action at the very end of the post inside its own <p> tag:\n"
-            f"Visit <a href='https://ultima-supply.myshopify.com'>Ultima Supply</a> to explore more collectibles."
-        )
-
-        blog_html = get_response(
-            input=prompt,
-            template=lambda x: x.strip(),
-            llm="gemini",
-            md=False,
-            temperature=0.9,
-            max_tokens=5000
-        )
-
-        blog_html = re.sub(r"```[a-zA-Z]*\n?", "", blog_html).strip()
-        blog_html = blog_html.replace("```", "").strip()
-
-        generated_blog.set((seo_title, blog_html))
-
-        return ui.HTML(
-            f"<p><strong>✅ Blog generated with title:</strong> {seo_title}</p>"
-            f"<p>Click 'Post to Shopify' to publish.</p>{blog_html}"
-        )
-
-    @output
-    @render.ui
-    def keywords_used_gen():
-        kws = related_keywords()
-        if not kws:
-            return ui.HTML("<p><strong>No SEO keywords retrieved yet.</strong></p>")
-
-        return ui.HTML(
-            f"<p><strong>✅ SEO Keywords Injected ({len(kws)}):</strong></p><ul>"
-            + "".join(f"<li>{kw}</li>" for kw in kws) +
-            "</ul>"
-        )
-
-    @reactive.effect
-    @reactive.event(input.blog_post_btn)
-    def post_to_shopify():
-        seo_title, html = generated_blog()
-
-        if not html:
-            ui.notification_show("⚠️ No blog generated yet.", type="warning")
-            return
-
-        success, response = publish_blog_post(title=seo_title, html_body=html)
-
-        if success:
-            ui.notification_show("✅ Blog posted to Shopify successfully!", type="message")
-        else:
-            ui.notification_show(f"❌ Failed to publish: {response}", type="error")
-

server/meta.py

@@ -4,6 +4,7 @@ import requests
 from dotenv import load_dotenv
 from bs4 import BeautifulSoup
 import subprocess
+import time
 from llm_connect import get_response
 
 load_dotenv()
@@ -67,6 +68,8 @@ def generate_facebook_post(topic: str = "", url: str = "", min_len: int = 500, m
 
     if len(post) <= max_len:
         return post
+    
+    time.sleep(5)
 
     # Step 2: Shorten if needed
     shorten_prompt = (

server/threads.py

@@ -3,6 +3,7 @@ import os
 import requests
 from dotenv import load_dotenv
 from bs4 import BeautifulSoup
+import time
 from llm_connect import get_response
 
 # Load env
@@ -74,6 +75,8 @@ def generate_threads_post(  # keeping the function name to avoid UI refactor
 
     if len(post) <= max_len:
         return post
+    
+    time.sleep(5)
 
     # Step 2: Shorten if needed
     shorten_prompt = (

server/twitter.py

@@ -4,6 +4,7 @@ import requests
 from bs4 import BeautifulSoup
 from dotenv import load_dotenv, find_dotenv
 import tweepy
+import time
 from llm_connect import get_response
 
 # Load environment variables
@@ -55,6 +56,8 @@ def generate_tweet_from_text(text: str, url: str='https://ultimasupply.com/blogs
     if len(tweet) <= max_len:
         return tweet
     else:
+        time.sleep(5)
+
         shorten_prompt = (
             f"You are shortening this tweet to {max_len} characters or fewer.\n"
             f"YOU MUST KEEP ALL of the original SEO hashtags and the Shopify blog link intact in the final output.\n"

ui/general_blog.py

@@ -1,19 +0,0 @@
-from shiny import ui
-
-ui = ui.nav_panel(
-    "General Blog Writer",
-
-    # Scoped URL input
-    ui.input_text("blog_url", "Enter Pokémon.com Article URL", placeholder="https://www.pokemon.com/us/..."),
-
-    # Scoped buttons
-    ui.div(
-        ui.input_action_button("blog_generate_btn", "Generate Blog from Article"),
-        ui.input_action_button("blog_post_btn", "Post to Shopify", class_="ms-3"),
-        class_="mt-3 mb-3"
-    ),
-
-    # Scoped outputs
-    ui.output_ui("blog_result_gen"),
-    ui.output_ui("blog_keywords_used_gen")
-)