Setting Up a Simple WooCommerce Product Social Media Post Generator Using LM Studio

				
					from flask import Flask, request, jsonify
from datetime import datetime
from sqlalchemy import create_engine, MetaData, select, insert, update  
from sqlalchemy.exc import SQLAlchemyError
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from apscheduler.schedulers.background import BackgroundScheduler
import requests
import logging
import json
import random
import pymysql
pymysql.install_as_MySQLdb()

SIMILARITY_THRESHOLD = 0.8  # Adjust this value as needed
MAX_ATTEMPTS = 3

app = Flask(__name__)

# Configure the database
app.config['SQLALCHEMY_DATABASE_URI'] = 'YOUR_MYSQL_URI'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# Initialize the database
database = create_engine(app.config['SQLALCHEMY_DATABASE_URI'])
metadata = MetaData()
metadata.reflect(bind=database)
Products_Posts = metadata.tables['products_posts']


@app.route('/')
def home():
    return "Social Media Content Generator API"
    

def get_ai_response(prompt):
    url = "http://localhost:1234/v1/chat/completions"
    headers = {"Content-Type": "application/json"}
    data = {
        "messages": [{"role": "user", "content": prompt}],
        "stop": ["### Instruction:"],
        "temperature": 0.3,
        "max_tokens": -1,
        "stream": False
    }
    try:
        response = requests.post(url, headers=headers, json=data)
        # Check if the response status code is 200 (OK)
        if response.status_code == 200:
            return response.json()  # You might need to extract the actual response text from the JSON response
        else:
            # Log the unexpected status code and response text
            app.logger.error(f"Unexpected status code from AI server: {response.status_code}. Response text: {response.text}")
            return None
    except requests.exceptions.RequestException as e:
        # Log the exception
        app.logger.error(f"An error occurred while sending request to AI server: {str(e)}")
        return None


@app.route('/process_posts', methods=['GET'])
def process_posts():
    try:
        with database.connect() as conn:
            # Select records with status 'open'
            open_posts_query = select(Products_Posts).where(Products_Posts.c.post_status == 'open')
            open_posts_result = conn.execute(open_posts_query).fetchall()

            processed_posts = 0
            for post in open_posts_result:
                # Assume create_post() returns a tuple (title, body)
                data_to_create = {
                "post_id": post.id,
                "product_name": post.name,
                "product_category": post.category_names,  
                "product_url": post.product_url,                
                "use_ai": True,
                "type": "product",
                }
                # Call the create function with the constructed data
                response, status_code = create(data=data_to_create)
                response_data = response.get_json()  
                # post_title, post_body = create(post)  # Call the function to create post

                # Update the current record with the new post_title and post_body
                update_query = (
                    update(Products_Posts)
                    .where(Products_Posts.c.id == post.id)
                    .values(
                        post_title=response_data["title"], 
                        post_body=response_data["content"],
                        post_status='processed'  # Update status to 'processed'
                    )
                )
                conn.execute(update_query)
                processed_posts += 1

            conn.commit()
            return jsonify(message=f"Processed {processed_posts} open posts."), 200
    except Exception as e:
        app.logger.error(f"An error occurred: {e}")
        return jsonify(message="An error occurred while processing the open posts."), 500

@app.route('/create', methods=['POST'])
def create(data=None):
    app.logger.info("Entering the create function with data: %s", data)

    if not data:
        data = request.get_json()

    with database.connect() as conn:
        app.logger.info("Entering the Database part")      
        product_query = select(Products_Posts.c.id, Products_Posts.c.name, Products_Posts.c.category_names, Products_Posts.c.product_url).where(Products_Posts.c.id == data['post_id'])
        thepost = data['post_id']
        app.logger.info("Entering the Post part %s", thepost)
        title_text = ''
        content_text = ''
        for attempt in range(MAX_ATTEMPTS):
            if data.get('use_ai'):
                # Formulate a prompt using the details provided
                # (If it's the first attempt, create the base prompt; else, append a note to it)
                prompt = f"### Instruction:  You are a Marketeer for QRAwards.com (QR Awards). QR Awards is a dedicated online gallery focusing on diverse award categories including sports trophies, academic awards, and employee recognition items. They enrich awards by offering a unique service of integrating a photo gallery to any award, making every recognition memorable. Beyond selling a wide array of custom awards and honor plaques through their website, QR Awards adds value by hosting a blog, imparting knowledge on sports history, trophies, and awards. The company is committed to making each honor memorable by providing extensive choices for various occasions, ensuring each award uniquely captures and commemorates achievements. Generate a social media post promoting the {data['product_name']} that belongs to the {data['product_category']} category prioritizing the promotion of product sales. Start the title of the post with 'Title:' and the body with 'Body:'. Keep each post concise and under 140 characters, highlighting the unique photo gallery integration service and the diverse selection of awards and plaques. Include appealing and clear calls-to-action encouraging viewers to explore and make a purchase on the QR Awards website. The Product URL is {data['product_url']}. ###Response: "
                if attempt == 0:
                     prprompt = f"### Instruction:  Please create a different post. ###Response: "
                else:
                    prompt += " Note: Please provide a different title and content than the previous attempts."
                # Get AI-generated content
                ai_response = get_ai_response(prompt)
                if not ai_response.get('choices') or not isinstance(ai_response['choices'], list) or not ai_response['choices']:
                    return jsonify(message="AI response is missing 'choices' or 'choices' is not a list or is empty"), 400

                if not ai_response['choices'][0].get('message'):
                    return jsonify(message="AI response is missing 'message' in the first choice"), 400

                if not ai_response['choices'][0]['message'].get('content'):
                    return jsonify(message="AI response is missing 'content' in the message of the first choice"), 400

                data['title'] = ai_response['choices'][0]['message']['content']  # Extracting the AI-generated title
                data['content'] = ai_response['choices'][0]['message']['content']  # Extracting the AI-generated content                
                # Find the start and end indices of the title and content
                title_start = data['title'].find('Title:') + len('Title:')
                body_start = data['content'].find('Body:') + len('Body:')
                title_end = data['title'].find('Body:')          
                # Get the substrings for the title and content using the indices found
                title_text = data['title'][title_start:title_end].strip()
                content_text = data['content'][body_start:].strip()
                data['title'] = title_text
                data['content'] = content_text
                app.logger.info("Title is %s", title_text)
                app.logger.info("Body is %s", content_text)
                # Check if title and content are not None
                if title_text is not None and content_text is not None:
                    app.logger.info("Checking")
                    # Check if title and content are not empty strings                   
                    if title_text.strip() and content_text.strip():
                        existing_posts_query = select(Products_Posts.c.post_title, Products_Posts.c.post_body)
                        existing_posts_result = conn.execute(existing_posts_query).fetchall()
                        existing_titles = [row[0] for row in existing_posts_result]
                        existing_contents = [row[1] for row in existing_posts_result]
                        if existing_posts_result:
                            # Exclude None values from existing titles and contents
                            existing_titles = [title for title in existing_titles if title is not None]
                            existing_contents = [content for content in existing_contents if content is not None]
                            # Ensure there is at least one valid document to calculate similarities
                            if existing_titles and existing_contents:
                                # Combine existing and new texts for TF-IDF vectorization
                                all_titles = existing_titles + [title_text]  # Use extracted title text here
                                all_contents = existing_contents + [content_text]  # Use extracted content text here

                                # Calculate TF-IDF vectors
                                title_vectorizer = TfidfVectorizer().fit_transform(all_titles)
                                content_vectorizer = TfidfVectorizer().fit_transform(all_contents)
                               
                                # Calculate cosine similarities
                                title_similarities = cosine_similarity(title_vectorizer[-1], title_vectorizer[:-1])
                                content_similarities = cosine_similarity(content_vectorizer[-1], content_vectorizer[:-1])

                                # Log the cosine similarity scores
                                app.logger.info(f"Title cosine similarities: {title_similarities.max()}")
                                app.logger.info(f"Content cosine similarities: {content_similarities.max()}")

                                if title_similarities.max() < SIMILARITY_THRESHOLD and content_similarities.max() < SIMILARITY_THRESHOLD:
                                    distinct_content_found = True
                                    break
                                elif attempt == MAX_ATTEMPTS - 1:
                                    # If the loop completes without breaking (i.e., distinct title and content were not found in 3 attempts)
                                    return jsonify(message="Unable to create a distinct post after 3 attempts"), 400
                            else:
                                # Handle case where there are no valid documents to calculate similarities
                                # return jsonify(message="Unable to create a distinct post after 3 attempts"), 400
                                distinct_content_found = True
                                break
                        else:
                            # Handle case where title or content is empty string
                            return jsonify(message="AI generated empty title or content"), 400                            
                    else:
                        # Handle case where title or content is None
                        return jsonify(message="AI generated title or content is None"), 400                          
        if not distinct_content_found:
            return jsonify(message="Unable to create a distinct post after 3 attempts"), 400
        # Check if title_text and content_text are not empty before inserting into the database
        if title_text and content_text:            
            # Insert the new post into the Posts table (This should be outside of the for loop)
            update_query = (
                update(Products_Posts)
                .where(Products_Posts.c.id == thepost)  
                .values(                        
                    post_title=data['title'],
                    post_body=data['content'],
                    post_status='draft'
                )
            )
            print(str(update_query.compile(compile_kwargs={"literal_binds": True})))
            try:
                result = conn.execute(update_query)
                conn.commit()  # Commit the transaction
                return jsonify(message="Post updated successfully", post_id=data['post_id'], title=data['title'], content=data['content']), 200
            except SQLAlchemyError as e:
                app.logger.error(f"Failed to insert record: {str(e)}")
                conn.rollback()  # Rollback the transaction in case of error
                return jsonify(message="An error occurred while updating the post"), 500            
        else:
            return jsonify(message="Failed to generate a valid title and content"), 400  
    
def run_auto_create():
    with app.test_request_context():
        auto_create()

scheduler = BackgroundScheduler()
scheduler.add_job(run_auto_create, 'interval', hours=1)
scheduler.start()

if __name__ == '__main__':
    app.run(debug=True)