Upload 4 files

generate_script.py

@@ -0,0 +1,76 @@
+from langchain_community.llms import Replicate
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+from langchain_community.tools import DuckDuckGoSearchRun
+import os
+
+def generate_script(prompt, video_length, creativity, replicate_api):
+    """
+    Generate a YouTube video title and script based on the provided prompt, duration, and creativity level.
+    
+    Parameters:
+        prompt (str): Topic of the video.
+        video_length (float): Desired duration of the video in minutes.
+        creativity (float): Creativity level (0.0 to 1.0).
+        replicate_api (str): Replicate API Key for authentication.
+    
+    Returns:
+        tuple: Generated title, script, and search data.
+    """
+    # Ensure the Replicate API key is set
+    if not replicate_api:
+        raise ValueError("Replicate API Key is missing.")
+    os.environ["REPLICATE_API_TOKEN"] = replicate_api
+
+    # Initialize the LLM with the Replicate model
+    llm = Replicate(
+        model="meta/meta-llama-3-8b-instruct",
+        input={
+        "top_k": 0,
+        "top_p": 0.95,
+        "prompt": prompt,
+        "max_tokens": 4096,
+        "temperature": 0.7,
+        "length_penalty": 1,
+        "max_new_tokens": 4096,
+        "presence_penalty": 0,
+        "log_performance_metrics": False
+    },
+    )
+
+    # Define the title generation prompt
+    title_template = PromptTemplate(
+        input_variables=["topic"],
+        template="Generate a YouTube video title for the topic '{topic}'."
+    )
+    title_chain = LLMChain(llm=llm, prompt=title_template, verbose=True)
+
+    # Define the script generation prompt
+    script_template = PromptTemplate(
+        input_variables=["title", "duration", "search_data"],
+        template=(
+            "Create a YouTube script with the title '{title}' that lasts approximately {duration} minutes. "
+            "Incorporate the following research information: {search_data}."
+        )
+    )
+    script_chain = LLMChain(llm=llm, prompt=script_template, verbose=True)
+
+    # Fetch relevant search data using DuckDuckGo
+    search_tool = DuckDuckGoSearchRun()
+    search_data = search_tool.run(prompt)
+
+    # Generate the video title
+    title = title_chain.run({"topic": prompt})
+
+    # Save the generated title to a file
+    with open("generated_title.txt", "w") as file:
+        file.write(title)
+
+    # Generate the video script
+    script = script_chain.run({
+        "title": title,
+        "duration": video_length,
+        "search_data": search_data
+    })
+
+    return title, script, search_data

imggen.py

@@ -0,0 +1,119 @@
+import streamlit as st
+import replicate
+import time
+from dotenv import load_dotenv
+import os
+import requests
+from io import BytesIO
+from PIL import Image
+import random
+
+# Load environment variables
+load_dotenv()
+
+# Check for a title from the script generator
+try:
+    with open("generated_title.txt", "r") as file:
+        title = file.read().strip()
+        prompt = title  # Use the title as the default prompt
+except FileNotFoundError:
+    st.warning("No title found! Please run the script generator first.")
+    prompt = ""  # Set an empty prompt if no title is available
+
+# Retrieve the API key
+replicate_api = st.secrets.get('REPLICATE_API_TOKEN') or os.getenv("REPLICATE_API_TOKEN")
+
+if not replicate_api:
+    st.error("API Key not provided! Please add it to Streamlit secrets or the .env file.")
+else:
+    os.environ['REPLICATE_API_TOKEN'] = replicate_api  # Set the API key for Replicate
+
+# Initialize session state for image history
+if "image_history" not in st.session_state:
+    st.session_state.image_history = []
+
+# Streamlit UI setup
+st.title("AI Image Generator")
+prompt = st.text_input("Enter a prompt for the image", value=prompt)  # Use the title as the default value
+styles = st.multiselect("Image artstyle", ['Impressionism', 'Cubism', 'Surrealism', 'Baroque', 'Art Noveau', 'Cyberpunk', 'Synthwave', 'Anime', 'Pixel Art', 'Low Poly', 'Dark Fantasy', 'Space Opera', 'Steampunk', 'Fantasy', 'Abstract','Glitch Art', 'Kawaii','Pop Art'])
+
+with st.sidebar:
+    st.title("Options")
+    aspect_ratio = st.selectbox("Aspect Ratio", ("16:9", "4:3", "3:2", "1:1", "21:9"))
+    seed = st.number_input("Seed (leave empty for random)", min_value=0, step=1, format="%d")
+    quality = st.slider("Quality", min_value=0, max_value=100, value=90, step=1)
+    strength = st.slider("Prompt Strength", min_value=0.0, max_value=1.0, value=0.9, step=0.01)
+    steps = st.slider("Sampling Steps", min_value=1, max_value=28, value=28, step=1)
+    cfg = st.slider("Similarity", min_value=0.0, max_value=20.0, value= 3.5, step=0.1)
+
+# Function to convert image URL to PNG buffer
+def get_image_buffer(image_url):
+    response = requests.get(image_url)
+    if response.status_code == 200:
+        image = Image.open(BytesIO(response.content))
+        buffer = BytesIO()
+        image.save(buffer, format="PNG")
+        buffer.seek(0)
+        return buffer
+    else:
+        return None
+
+# Handle image generation
+if st.button("Generate Image"):
+    seed = int(seed) if seed else random.randint(0, 99999)
+
+    if not prompt:
+        st.error("Please enter a prompt!")
+    else:
+        with st.spinner('Generating image...'):
+            start_time = time.time()
+            try:
+                # Replicate API call
+                output = replicate.run(
+                    "stability-ai/stable-diffusion-3",
+                    input={
+                        "cfg": cfg,
+                        "steps": steps,
+                        "prompt": f"With this context of the prompt: {prompt}, make me a video thumbnail with these artstyles: {styles}",
+                        "aspect_ratio": aspect_ratio,
+                        "output_format": "png",
+                        "output_quality": quality,
+                        "negative_prompt": "bad quality, worse quality, deformed",
+                        "prompt_strength": strength,
+                        "seed": seed
+                    }
+                )
+                # Display output and elapsed time
+                if output:
+                    image_url = output[0]
+                    st.image(image_url, caption="Generated Image", use_container_width=True)
+                    end_time = time.time()
+                    elapsed_time = end_time - start_time
+                    st.write(f"Image Generated in {elapsed_time:.2f} seconds")
+
+                    # Save to session state
+                    st.session_state.image_history.append((image_url, prompt))
+                else:
+                    st.error("No output received. Please try again!")
+            except Exception as e:
+                st.error(f"An error occurred: {str(e)}")
+
+# Display image history
+with st.expander("Show Prompt History"):
+    if st.session_state.image_history:
+        for idx, (image_url, image_prompt) in enumerate(reversed(st.session_state.image_history)):
+            st.subheader(f"Image {len(st.session_state.image_history) - idx}")
+            st.text(f"Prompt: {image_prompt}")
+            st.image(image_url, use_container_width=True)
+
+            # Generate download button for each image
+            buffer = get_image_buffer(image_url)
+            if buffer:
+                st.download_button(
+                    label="Download Image",
+                    data=buffer,
+                    file_name=f"generated_image_{len(st.session_state.image_history) - idx}.png",
+                    mime="image/png"
+                )
+    else:
+        st.write("No images generated yet.")

scriptgen.py

@@ -0,0 +1,53 @@
+import streamlit as st
+from dotenv import load_dotenv
+from generate_script import generate_script
+import os
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Streamlit app title and subtitle
+st.title("YouTube-Inator")
+st.subheader("Make fun stuff with YouTube-Inator!")
+
+with st.sidebar:
+    st.title("Options")
+    creativity = st.slider("Set creativity level:", min_value=0.0, max_value=1.0, value=0.5)
+
+
+# Input fields for video generation parameters
+prompt = st.text_input("Provide the topic of the video:", placeholder="e.g., How to bake a cake")
+video_length = st.number_input("Specify length in minutes", min_value=1.0, step=0.5, value= 10.0)
+
+# Button to generate the video script
+generate_script_button = st.button("Generate Script")
+
+# Generate script on button click
+if generate_script_button:
+    if not replicate_api:
+        st.error("Please provide a valid API Key.")
+    else:
+        # Set the API Key in the environment variable for use by other modules
+        os.environ["REPLICATE_API_TOKEN"] = replicate_api
+        
+        try:
+            # Generate the video script using the utility function
+            with st.spinner("Generating your script..."):
+                title, script, search_data = generate_script(prompt, video_length, creativity, replicate_api)
+            
+            # Display the results
+            st.success("Script generated successfully!")
+            st.subheader(f"Title: {title}")
+            st.write(f"Script: {script}")
+            
+            # Display additional search data
+            with st.expander("Show search data for the script"):
+                st.write(search_data)
+        
+        except Exception as e:
+            # Handle any errors that occur during script generation
+            st.error(f"An error occurred. Try again {e}")
+            with st.expander("Expand to see details"):
+                st.write(f'{e}')
+
+            

tweaker.py

@@ -0,0 +1,98 @@
+import streamlit as st
+from langchain_community.llms import Replicate
+from langchain.chains import ConversationChain
+from langchain.memory import ConversationSummaryMemory
+from langchain.prompts import ChatPromptTemplate
+import os
+
+# Setting page title and header
+st.title("Creative Consultant")
+st.subheader("Make fun stuff with YouTube-Inator!")
+
+# Sidebar for API key input and summarisation
+with st.sidebar:
+    # Button to summarise the conversation
+    summarise_button = st.button("Summarise the conversation", key="summarise_button")
+
+    # Check if the summarise button was clicked
+    if summarise_button:
+        if st.session_state.get('conversation') and st.session_state['conversation'].memory:
+            # Generate the summary
+            summary = st.session_state['conversation'].memory.buffer
+            st.session_state['summary'] = summary  # Store in session state
+            st.write("Summary:\n\n" + summary)
+        else:
+            # Handle case where no conversation memory exists
+            summary = "No conversation to summarise leh!"
+            st.write(summary)
+
+    # Add a download button if a summary exists
+    if st.session_state.get('summary'):
+        st.download_button(
+            label="Download Summary",
+            data=st.session_state['summary'],
+            file_name="conversation_summary.txt",
+            mime="text/plain",
+        )
+
+# Initialize conversation state if not already done
+if 'conversation' not in st.session_state:
+    st.session_state['conversation'] = None
+if 'messages' not in st.session_state:
+    st.session_state['messages'] = []
+if 'REPLICATE_API_TOKEN' not in st.session_state:
+    st.session_state['REPLICATE_API_TOKEN'] = ''
+
+# Function to get response from OpenAI model
+def get_response(user_input, replicate_api):
+    if st.session_state['conversation'] is None:
+        llm = Replicate(
+            model=("meta/meta-llama-3-8b-instruct"),
+            model_kwargs={
+                "temperature": 0.01,
+                "top_p": 0.9,
+                "max_length": 128,
+            },
+        )
+        st.session_state['conversation'] = ConversationChain(
+            llm=llm,
+            verbose=True,
+            memory=ConversationSummaryMemory(llm=llm),
+        )
+    # Call the conversation chain
+    response_dict = st.session_state['conversation'].invoke(input=user_input)
+    
+    # Extract the response field only
+    return response_dict.get("response", "No response generated leh!")
+
+# Function to get user input
+def get_text():
+    chat_input = st.chat_input("Say Hello")
+    return chat_input
+
+# Display chat history
+if st.session_state.messages:
+    for msg in st.session_state.messages:
+        with st.chat_message(msg["role"]):
+            st.markdown(msg["content"])
+
+# Get user input
+user_input = get_text()
+
+if user_input:
+    try:
+        # Get the response from the LLM
+        response = get_response(user_input, st.session_state['REPLICATE_API_TOKEN'])
+        
+        # Append the user message to session state
+        st.session_state.messages.append({"role": "user", "content": user_input})
+        with st.chat_message("user"):
+            st.markdown(user_input)
+
+        # Append and display the LLM response
+        st.session_state.messages.append({"role": "LLM", "content": response})
+        with st.chat_message("LLM"):
+            st.markdown(response)
+
+    except Exception as e:
+        st.error(f"An error occurred: {e}")