Upload 35 files

.env

@@ -0,0 +1 @@
+OPENAI_API_KEY='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'

README.md

@@ -1,13 +1,2 @@
----
-title: TextGen
-emoji: ⚡
-colorFrom: red
-colorTo: gray
-sdk: streamlit
-sdk_version: 1.29.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Feather
+Feather AI

X_content_creation.py

@@ -0,0 +1,83 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+class X_Generator:
+
+        
+    def __init__(self, llm):
+        self.llm = llm
+
+
+    def x_camp_gen(self, product_name, product_desc, goal):
+    
+        x_camp_prompt = f"Design a potent Twitter campaign for my product '{product_name}'. {product_name} is {product_desc} aiming to accomplish {goal} through the meticulous adoption of planning and content creation best practices.\n\nCampaign will include: Campaign Teaser, Educational Content Series, Customer Testimonials and Case Studies, Interactive Content, Limited-Time Offer Announcement, Call-to-Action for Consultation and  Recap and Thank You."
+        print(x_camp_prompt)
+        x_camp_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are a Specialist in Twitter Copywriting\n\n{text_input}\n\nMake the tweets engaging, creative and coherent")
+        x_camp_extraction_chain = LLMChain(llm=self.llm, prompt=x_camp_promptTemp)
+        x_camp = x_camp_extraction_chain.run(x_camp_prompt)
+    
+        return x_camp
+
+    def x_retweet_commenting_gen(self, tweet, tone_of_voice):
+    
+        x_retweet_comment_prompt = f"I'm planning to retweet the following tweet:\n“{tweet}”\nConstruct 5 varied comments I could append to this retweet. tone should be {tone_of_voice}"
+        x_retweet_comment_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are Specilaized Twitter Copywriter\n{text_input}\n\nRetweet Comment:")
+        x_retweet_comment_extraction_chain = LLMChain(llm=self.llm, prompt=x_retweet_comment_promptTemp)
+        x_retweet_comment = x_retweet_comment_extraction_chain.run(x_retweet_comment_prompt)
+        
+        return x_retweet_comment
+
+    def X_thread_gen(self, topic, num_tweets, tone_of_voice):
+    
+        X_thread_prompt = f"Write a an engagging Twitter Thread  on '{topic}' consists of {num_tweets} tweets. Tone should be {tone_of_voice}"
+            
+        X_thread_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are a Twitter Content Creator:\n{text_input}\n\nTwitter Thread:")
+    
+        X_thread_extraction_chain = LLMChain(llm=self.llm, prompt=X_thread_promptTemp)
+        X_thread = X_thread_extraction_chain.run(X_thread_prompt)
+        
+        return X_thread
+    
+    def X_thread_gen_intro(self, topic, thread, tone_of_voice):
+    
+        X_thread_prompt = f"Write a an engagging and attractive Introduction head tweet for my twitter thread on {topic}. here is my twitter thread:\n{thread}\nTone should be {tone_of_voice}"
+            
+        X_thread_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are a Twitter Content Creator:\n{text_input}\n\nTweet:")
+    
+        X_thread_extraction_chain = LLMChain(llm=self.llm, prompt=X_thread_promptTemp)
+        X_thread = X_thread_extraction_chain.run(X_thread_prompt)
+        
+        return X_thread
+    
+    def x_bio_gen(self, info, tone_of_voice):
+    
+        x_bio_prompt = f"Craft a personalized Twitter bio for me, based on the content I create, related to {info}. tone should be {tone_of_voice}, Produce 10 tailor-made Twitter bios for me."
+        x_bio_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are a copywriter\n{text_input}\n\nTwitter Bios:")
+        x_bio_extraction_chain = LLMChain(llm=self.llm, prompt=x_bio_promptTemp)
+        x_bio = x_bio_extraction_chain.run(x_bio_prompt)
+        
+        return x_bio
+    
+    def article_to_x_thread_gen(self, article):
+    
+        article_to_x_thread_prompt = f"Transform the ensuing article into a sequence of Twitter posts, creating a coherent Twitter thread between 5 to 20 tweets\nArticle: “{article}.“"
+        article_to_x_thread_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are a twitter copywriter\n{text_input}\n\nCoherent Twitter Thread:")
+        article_to_x_thread_extraction_chain = LLMChain(llm=self.llm, prompt=article_to_x_thread_promptTemp)
+        article_to_x_thread = article_to_x_thread_extraction_chain.run(article_to_x_thread_prompt)
+        
+        return article_to_x_thread
+
+
+

app.py

@@ -0,0 +1,434 @@
+from remove_astricks import remove_ast
+from load_model import call_palm
+from keywords_generation import keywords_generator, filter_keywords, process_keywords
+from idea_generation import ideas_generator, filter_ideas
+from outline_generation import outlines_generator, filtered_outlines
+from article_generation import  full_article, rephrase
+from product_description_generation import product_description_gen
+from x_thread_generation import X_thread_gen, X_thread_gen_intro
+from linkedin_post_generation import linkedIn_post_gen
+from insta_image_caption_generation import img2text, generate_InstaCap
+from facebook_post_generation import facebook_post_gen
+from facebook_ads_generation import facebook_ads_gen
+from facebook_campaign import facbook_camp_gen, social_media_camp_gen
+from linkedIn_ads_generation import linkedIn_ads_gen
+from email_marketing_campaigns_generation import email_marketing_campaigns_gen
+from workout_plan_generation import workout_plan_gen
+from landing_page_generation import landing_page_gen
+from blog_post_generation import blog_post_gen
+from x_bio_creation import x_bio_gen
+from x_retweet_commenting_generation import x_retweet_commenting_gen
+from article_conversion_to_x_thread import article_to_x_thread_gen
+from x_campaign_generation import x_camp_gen
+from blog_ideas_generation import blog_idea_gen
+from blog_ideas_description_generation import blog_idea_desc_gen
+from blog_post_tags_generation import blog_tags_gen
+import X_content_creation
+import blog_content_creation
+import meta_content_creation
+import email_writer
+
+import streamlit as st
+from dotenv import load_dotenv, find_dotenv
+import os
+import time
+
+load_dotenv(find_dotenv())
+google_api_key = os.environ['OPENAI_API_KEY']
+
+
+if __name__ == '__main__':
+
+    llm = call_palm(google_api_key) 
+    
+    tone_of_voice_list = ('Excited', 'Professional', 'Encouraging', 'Funny', 'Dramatic', 'Witty', 'Sarcastic', 'Engaging', 'Creative')
+    creativity_list = ('Original', 'Creative', 'Visionary')
+
+    with st.sidebar:
+
+        st.image('Logo.png')
+        choice = st.radio("Navigation", ["Articles and Blogs", "Product Description", "LinkedIn Post", "LinkedIn Ads", "Gym Workout Plan", "Landing Page", "X Content Creation", "Meta Content", "Emails"])
+        st.info("Generate your Content with Feather AI in Seconds..")
+
+  
+
+    if choice == 'Product Description':
+
+        product_name = st.text_input('Product Name')
+        product_desc =  st.text_area('Product Description')
+        tone_of_voice = st.selectbox('Tone of Voice', tone_of_voice_list)
+
+        if product_name and product_desc and tone_of_voice:
+
+            if st.button('Generate'):
+
+                product_description = product_description_gen(product_name, product_desc, tone_of_voice, llm)
+                st.markdown(product_description)
+
+    elif choice == 'LinkedIn Post':
+
+        topic = st.text_input("Topic")
+        tone_of_voice = st.selectbox('Tone of Voice', tone_of_voice_list)
+        
+        if topic and tone_of_voice:
+            
+            if st.button('Generate'):
+
+                linkedIn_post = linkedIn_post_gen(topic, tone_of_voice, llm)
+                st.markdown(linkedIn_post)
+
+
+    elif choice == "LinkedIn Ads":
+
+        product_name = st.text_input("Product Name")
+        product_desc = st.text_area("Product Description")
+        target_audience = st.text_input("Target Audience")
+        target_keywords = st.text_input("Target Keywords")
+
+        if product_name and product_desc and target_audience and target_keywords:
+            
+            if st.button("Generate"):
+
+                linkedIn_ad = linkedIn_ads_gen(product_name, product_desc, target_audience, target_keywords, llm)
+                st.markdown(linkedIn_ad)
+
+
+    elif choice == "Gym Workout Plan":
+
+        fitness_level_list = ('Beginner', 'Intermediate', 'Advanced', 'Elite')
+        health_consd_list = ('Cutting Phase', 'Bulking Phase', 'Maintenance Phase', 'Lean Muscle Gain')
+        routine_list = ('Bro Split', 'Push Pull Leg', 'Upper and Lower', 'Full Body')
+
+        fitness_level = st.selectbox('Fitness Level', fitness_level_list)
+        days = st.slider('Avaliable Days Per Week',1,7,4)
+        hours = st.slider('Avaliable Hours Per Day',1,6,2)
+        health_consd = st.selectbox('Health Considerations',health_consd_list)
+        routine = st.selectbox("Preferred Routine", routine_list)
+        my_goals = st.text_input('Goals')
+
+        if fitness_level  and days and hours and health_consd and routine and my_goals: 
+
+            if st.button('Generate'):
+                
+                workout_plan = workout_plan_gen(my_goals, fitness_level, days, hours, health_consd, routine, llm)
+                st.markdown(workout_plan)
+
+    elif choice == "Landing Page":
+
+        #product_name = st.text_input('Product Name')
+        #product_desc = st.text_area('Description')
+        #target_audience = st.text_input('Target Audience')
+        #goal = st.text_input('Goal')
+        st.title('Not Working')
+        #if product_name and product_desc and target_audience and goal:
+
+            #if st.button('Generate'):
+
+                #landing_page = landing_page_gen(product_name, product_desc, target_audience, goal, llm)
+                #st.markdown(landing_page)
+
+    
+    elif choice == 'X Content Creation':
+
+        X_content = X_content_creation.X_Generator(llm)
+
+        x_choices_list = ('X thread', 'X Retweet Commenting', 'X Campaign', 'X Bio Creation', 'Article Conversion to X Thread')
+        
+        x_choices = st.selectbox('Choose X Template', x_choices_list)
+
+        if x_choices == x_choices_list[0]:
+
+            topic = st.text_input('Topic')
+            num_tweets = st.slider('Number of Thread tweet', 1,10,5)
+            tone_of_voice = st.selectbox('Tone of Voice', tone_of_voice_list)
+
+            if topic and num_tweets and tone_of_voice:
+                
+                if st.button('Generate'):
+
+                    X_thread = X_content.X_thread_gen(topic, num_tweets, tone_of_voice)
+                    intro = X_content.X_thread_gen_intro(topic, X_thread, tone_of_voice)
+                    st.markdown(intro)
+                    st.markdown(X_thread)
+
+        elif x_choices == x_choices_list[1]:
+
+
+            tweet = st.text_area('Tweet')
+            tone_of_voice = st.selectbox('Tone of voice', tone_of_voice_list)
+
+            if tweet and tone_of_voice:
+
+                if st.button('Generate'):
+
+                    x_retweet_comment = X_content.x_retweet_commenting_gen(tweet, tone_of_voice)
+                    st.markdown(x_retweet_comment)
+
+        elif x_choices == x_choices_list[2]:
+
+            product_name = st.text_input('Product Name')
+            product_desc = st.text_area('Product Description')
+            goal = st.text_input('Goal')
+
+
+            if product_name and product_desc and goal:
+
+                if st.button('Generate'):
+
+                    x_camp = X_content.x_camp_gen(product_name, product_desc, goal)
+                    st.markdown(x_camp)
+
+        elif x_choices == x_choices_list[3]:
+
+            info = st.text_area('info')
+            tone_of_voice = st.selectbox('Tone of voice', tone_of_voice_list)
+
+            if info and tone_of_voice:
+
+                if st.button('Generate'):
+
+                    x_bio = X_content.x_bio_gen(info, tone_of_voice, llm)
+                    st.markdown(x_bio)
+
+        elif x_choices == x_choices_list[4]:
+
+            article = st.text_area('Article')
+
+            if article:
+
+                if st.button('Generate'):
+
+                    article_to_x_thread = X_content.article_to_x_thread_gen(article)
+                    st.markdown(article_to_x_thread)
+
+    elif choice == 'Articles and Blogs':
+
+        blog_content = blog_content_creation.blog_content_generation(llm)
+
+        blog_choices_list = ('Article Writer', 'Blog Post', 'Blog Ideas', 'Blog Tags', 'Blog Ideas description')
+        
+        blog_choices = st.selectbox('Choose Blog Template', blog_choices_list)
+
+        if blog_choices == blog_choices_list[0]:
+            
+            topic = st.text_input('Topic')
+            tone_of_voice = st.selectbox('Tone of Voice', tone_of_voice_list)
+
+            if topic:
+
+                keywords = keywords_generator(topic, llm)
+                filtered_keywords = filter_keywords(keywords)
+                formatted_keywords = process_keywords(filtered_keywords)
+
+                st.markdown('### Generated Keywords:\n')
+                st.markdown(formatted_keywords)
+
+                formatted_keywords = remove_ast(formatted_keywords)
+
+                idea_numbers = st.slider("How many ideas you want?",1,10,5)
+
+                ideas = ideas_generator(topic, formatted_keywords, llm, tone_of_voice, idea_numbers)
+                filtered_ideas = filter_ideas(ideas)
+                
+                index = 1
+
+                st.markdown("### Generated Ideas:\n")
+                for idea in filtered_ideas:
+
+                    st.markdown(f"{index} - {idea}")
+                    index+=1
+
+                st.text('\n')
+                num_idea = st.text_input("Choose the idea you want by number")
+
+                if num_idea:
+
+                    num_idea = int(num_idea)
+                    idea = filtered_ideas[num_idea-1]
+                    idea = remove_ast(idea)
+
+                    outline = outlines_generator(idea,formatted_keywords, llm)
+                    st.text('\n')
+                    st.markdown("### Generated Outline:\n")
+                    st.markdown(outline)
+                    outline_list = filtered_outlines(outline)
+
+
+                    if st.button('Generate'):
+
+                        article = full_article(idea, outline_list, tone_of_voice, llm)
+
+                        st.markdown("# Your Article:\n")
+                        st.markdown(f"{idea}\n")
+                        st.markdown('\n\n'.join(article))
+                        st.text('\n\n')
+                        num_art_chars = len('\n'.join(article))
+                        num_art_words = len('\n'.join(article).split(' '))
+
+                        st.markdown(f"{num_art_chars} Characters")
+                        st.markdown(f"{num_art_words} Words")
+
+        elif blog_choices == blog_choices_list[1]:
+
+            topic = st.text_input('Topic')
+
+            if topic:
+
+                if st.button('Generate'):
+                    blog_post = blog_content.blog_post_gen(topic)
+                    st.markdown(blog_post)
+
+        elif blog_choices == blog_choices_list[2]:
+
+            topic = st.text_input('Topic')
+
+            if topic:
+
+                if st.button('Generate'):
+
+                    blog_idea = blog_content.blog_idea_gen(topic)
+                    st.markdown(blog_idea)
+
+        elif blog_choices == blog_choices_list[4]:
+
+            blog = st.text_area('Blog')
+
+            if blog:
+
+                if st.button('Generate'):
+
+                    blog_idea_desc = blog_content.blog_idea_desc_gen(blog)
+                    st.markdown(blog_idea_desc)
+
+        elif blog_choices == blog_choices_list[3]:
+
+            blog = st.text_area('Blog')
+
+            if blog:
+
+                if st.button('Generate'):
+
+                    blog_tags = blog_content.blog_tags_gen(blog)
+                    st.markdown(blog_tags)
+
+    elif choice == 'Meta Content':
+        
+        meta_content_gen = meta_content_creation.meta_content_generation(llm)
+
+        meta_choices_list = ('Facebook Post', 'Facebook Ads', 'Facebook Campaign', 'Insta Image Captioning')
+        
+        meta_choices = st.selectbox('Choose Blog Template', meta_choices_list)
+
+
+        if meta_choices == meta_choices_list[0]:
+
+            topic = st.text_input("Topic")
+
+            tone_of_voice = st.selectbox('Tone of Voice', tone_of_voice_list)
+
+            if topic and tone_of_voice:
+
+                if st.button('Generate'):
+
+                    facebook_post = meta_content_gen.facebook_post_gen(tone_of_voice, topic)
+                    st.markdown(facebook_post)
+
+        elif meta_choices == meta_choices_list[1]:
+
+            product_name = st.text_input('Product Name')
+            product_desc = st.text_area('Description')
+            targeted_audience = st.text_input('Target Audience')
+            plans_proms = st.text_input('Plan and Promotions')
+
+            tone_of_voice = st.selectbox('Tone of Voice', tone_of_voice_list)
+            creativity = st.selectbox('Creativity', creativity_list)
+
+            if product_name and product_desc and tone_of_voice:
+
+                if st.button('Generate'):
+
+                    face_ad__prom = meta_content_gen.facebook_ads_gen(product_name, product_desc, tone_of_voice, targeted_audience, plans_proms)
+                    st.markdown(face_ad__prom)
+
+        elif meta_choices == meta_choices_list[2]:
+
+            product_name = st.text_input('Product Name')
+            product_desc = st.text_area('Product Description')
+            days = st.selectbox('Days', (10,15,20,25,30))
+            goal = st.text_input('Goal')
+
+            if product_name and product_desc and goal and days:
+
+                if st.button('Generate'):
+
+                    facbook_camp = meta_content_gen.facbook_camp_gen(product_name, product_desc, days, goal)
+                    st.markdown(facbook_camp)
+
+        elif meta_choices == meta_choices_list[3]:
+
+            uploaded_file = st.file_uploader("Choose an image...", type=["jpg","jpeg","png"])
+
+            if uploaded_file is not None:
+                    
+                    bytes_data = uploaded_file.getvalue()
+                    with open(uploaded_file.name, "wb") as file:
+                        file.write(bytes_data)
+                    
+                    st.image(uploaded_file, caption="Uploaded image",
+                        use_column_width=True, width=500)
+                    
+                    scenario = meta_content_gen.img2text(uploaded_file.name)
+
+                    st.subheader("Image Scenario:")
+                    with st.expander("scenario"):
+                        st.write(scenario)
+
+                    tone_of_voice = st.selectbox('Tone of Voice', tone_of_voice_list)
+                    form = st.selectbox('Caption Form', ('Short Form', 'Medium Form', 'Long Form'))
+
+                    if st.button('Generate'):
+
+                        st.subheader("Generated Instagram Image according to the scenario:")                    
+                        instaCap = meta_content_gen.generate_InstaCap(scenario, tone_of_voice, form)
+                        st.markdown(instaCap)
+
+    elif choice == 'Emails':
+
+        email_content_gen = email_writer.email_writing(llm)
+
+        email_choices_list = ('Email Writer', 'Email Marketing Campaign')
+        
+        email_choices = st.selectbox('Choose Emai Template', email_choices_list)
+
+        if email_choices == email_choices_list[0]:
+
+            recipient = st.text_input('Recipient')
+            recipient_position = st.text_input('Recipient Position')
+            sender_name = st.text_input('Sender Name')
+            position_sender = st.text_input('Sender Position')
+            description = st.text_area('Description')
+
+            if recipient and recipient_position and sender_name and position_sender and description:
+
+                if st.button('Generate'):
+                    
+                    email = email_content_gen.email_gen(recipient, recipient_position, sender_name, position_sender, description)
+                    email_subject = email_content_gen.email_subject_gen(email)
+                    st.markdown(f'Subject: {email_subject}')
+                    st.markdown(email)
+
+        elif email_choices == email_choices_list[1]:
+
+            product_name = st.text_input("Product Name")
+            product_description = st.text_area("Product Description")
+            target_audience = st.text_input("Target Audience")
+            goal = st.text_input("Goal")
+
+            if product_name and product_description and target_audience and goal:
+                
+                if st.button("Generate"):
+
+                    email_marketing_camp = email_content_gen.email_marketing_campaigns_gen(product_name, product_description, target_audience, goal)
+                    st.markdown(email_marketing_camp)
+
+

article_conversion_to_x_thread.py

@@ -0,0 +1,15 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def article_to_x_thread_gen(article, llm):
+    
+    article_to_x_thread_prompt = f"Transform the ensuing article into a sequence of Twitter posts, creating a coherent Twitter thread between 5 to 20 tweets\nArticle: “{article}.“"
+    article_to_x_thread_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a twitter copywriter\n{text_input}\n\nCoherent Twitter Thread:")
+    article_to_x_thread_extraction_chain = LLMChain(llm=llm, prompt=article_to_x_thread_promptTemp)
+    article_to_x_thread = article_to_x_thread_extraction_chain.run(article_to_x_thread_prompt)
+    
+    return article_to_x_thread
+
+

article_generation.py

@@ -0,0 +1,80 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def article_generator(idea, outline, section, llm, tone_of_voice):
+    
+    '''
+    Description:
+        This function generates paragraphs for an article based on provided inputs such as the main idea, outline, specific section, Long Language Model (LLM), and desired tone of voice. 
+        It uses a language model to create content either for a catchy introduction paragraph or to expand the article based on an existing outline.
+
+    Parameters:
+        idea (str) -> Required: The main idea or topic of the article.
+        outline (str) -> Required: The existing outline (if any) that has been covered in the article.
+        section (str) -> Required: The specific section or point that needs content creation or elaboration.
+        llm -> Required: The Long Language Model (LLM) used for generating article content.
+        tone_of_voice (str) -> Required: The intended tone of the article (e.g., professional, conversational, persuasive).
+
+    Return Value:
+        article (str): The generated article paragraph based on the provided inputs.
+    '''
+
+    if len(outline) == 0:
+        article_prompt = f"Generate Catchy Introduction paragraph for my article on {idea} using the following main point: {section}\nThe tone should be {tone_of_voice}."
+    else:
+        article_prompt = f"Generate well-organized paragraph for my article on {idea}. I have already covered: {outline} in the outline. I need help with the following main point: {section}. Please ensure the paragraphs are connected logically and provide a smooth transition between main topics. The tone should be {tone_of_voice}."
+
+    article_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a Professional content creator and article Writer:\n\n{text_input}\n\nParagraph:")
+    
+    print(article_prompt)
+    article_extraction_chain = LLMChain(llm=llm, prompt=article_promptTemp)
+    article = article_extraction_chain.run(article_prompt)
+    
+    return article
+
+def full_article(idea, outline_list, tone_of_voice, llm):
+    
+    '''
+    Description:
+        This function generates a full article by iteratively calling the article_generator function for each section in the provided outline list. It accumulates paragraphs generated for each section to construct a complete article based on the specified idea, outline, tone of voice, and Long Language Model (LLM).
+
+    Parameters:
+        idea (str) -> Required: The main idea or topic for the article.
+        outline_list (list) -> Required: A list containing sections or subsections for the article's structure.
+        tone_of_voice (str) -> Required: The desired tone of the article (e.g., professional, conversational, persuasive).
+        llm -> Required: The Long Language Model (LLM) used for generating article content.
+
+    Return Value:
+        article (list): A list of paragraphs representing the article content for each section in the provided outline.
+    '''
+    
+    article = []
+    outline = []
+    
+    try:
+        
+        for section in outline_list:
+
+            para = article_generator(idea, ' '.join(outline), section, llm, tone_of_voice)
+            outline.append(section)
+            article.append(para)
+            
+    except:
+        pass
+    
+    return article
+
+def rephrase(par, llm):
+    
+    paraCheck_prompt = f"Rephrase the following paragraph and make it more unique and excited: {par}"
+
+    paraCheck_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a content creator.\n{text_input}")
+   
+    paraCheck_extraction_chain = LLMChain(llm=llm, prompt=paraCheck_promptTemp)
+    rephrased_paragraph = paraCheck_extraction_chain.run(paraCheck_prompt)
+    
+    return rephrased_paragraph

blog_content_creation.py

@@ -0,0 +1,98 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+class blog_content_generation:
+
+    '''
+    Description:
+        This Python class, blog_content_generation, is designed to facilitate the creation of various blog-related content using a language model (LLM). 
+        It offers functionalities to generate blog post ideas, descriptions, actual posts, and relevant tags for search engine optimization (SEO).
+        
+    Class Methods:
+        __init__(self, llm)
+
+            Description: Initializes the blog_content_generation class by setting the language model (llm) to be used for content generation.
+            Parameters:
+            llm: The language model instance used for generating content.
+        
+        blog_idea_desc_gen(self, blog)
+
+            Description: Generates SEO-friendly titles and meta descriptions for a given blog post topic.
+            Parameters:
+            blog: The title or topic of the blog post.
+            Returns:
+            blog_idea_desc: A list of suggested titles and meta descriptions.
+            
+        blog_idea_gen(self, topic)
+
+            Description: Creates a list of SEO-friendly blog post ideas with emotional and persuasive titles based on a specific topic.
+            Parameters:
+            topic: The subject or theme for which blog post ideas are requested.
+            Returns:
+            blog_idea: A list containing at least 10 suggested blog post ideas.
+            
+        blog_post_gen(self, topic)
+
+            Description: Generates a blog post on a given topic.
+            Parameters:
+            topic: The subject or theme for the blog post content.
+            Returns:
+            blog_post: The generated blog post content.
+            
+        blog_tags_gen(self, blog)
+
+            Description: Suggests tags for a specific blog post.
+            Parameters:
+            blog: The title or topic of the blog post for which tags are needed.
+            Returns:
+            blog_tags_desc: A list of suggested tags related to the provided blog post.
+    '''
+    
+    def __init__(self, llm):
+        self.llm = llm
+
+
+    def blog_idea_desc_gen(self, blog):
+    
+        blog_idea_desc_prompt = f"Suggest at least 5 SEO-friendly titles and meta descriptions for the following blog post {blog}. Use a persuasive and intriguing tone."
+        blog_idea_desc_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are my blogger writter\n\n{text_input}\n\nSEO blog post ideas:")
+        blog_idea_desc_extraction_chain = LLMChain(llm=self.llm, prompt=blog_idea_desc_promptTemp)
+        blog_idea_desc = blog_idea_desc_extraction_chain.run(blog_idea_desc_prompt)
+        
+        return blog_idea_desc
+
+    def blog_idea_gen(self, topic):
+    
+    
+        blog_idea_prompt = f"Create a list of at least 10 blog post ideas on the following topic: {topic}. Suggest SEO-Friendly title and use an emotional and persuasive tone in blog post titles."
+        blog_idea_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are my blogger writter\n\n{text_input}\n\nSEO blog post ideas:")
+        blog_idea_extraction_chain = LLMChain(llm=self.llm, prompt=blog_idea_promptTemp)
+        blog_idea = blog_idea_extraction_chain.run(blog_idea_prompt)
+        
+        return blog_idea
+
+    def blog_post_gen(self, topic):
+    
+        blog_post_prompt = f"Write a blog Plost about {topic}."
+        blog_post_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are a Professional Content Creator and Blog Writer:\n{text_input}\nBlog Post:")
+        blog_post_extraction_chain = LLMChain(llm=self.llm, prompt=blog_post_promptTemp)
+        blog_post = blog_post_extraction_chain.run(blog_post_prompt)
+        
+        return blog_post
+        
+    def blog_tags_gen(self, blog):
+    
+        blog_tags_desc_prompt = f" Suggest at least 5 tags for the following blog post.\n{blog}"
+        blog_tags_desc_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are my blogger writter\n\n{text_input}\n\nSEO blog post ideas:")
+        blog_tags_desc_extraction_chain = LLMChain(llm=self.llm, prompt=blog_tags_desc_promptTemp)
+        blog_tags_desc = blog_tags_desc_extraction_chain.run(blog_tags_desc_prompt)
+        
+        return blog_tags_desc

blog_ideas_description_generation.py

@@ -0,0 +1,15 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def blog_idea_desc_gen(blog, llm):
+    
+    
+    blog_idea_desc_prompt = f"Suggest at least 5 SEO-friendly titles and meta descriptions for the following blog post {blog}. Use a persuasive and intriguing tone."
+    blog_idea_desc_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are my blogger writter\n\n{text_input}\n\nSEO blog post ideas:")
+    blog_idea_desc_extraction_chain = LLMChain(llm=llm, prompt=blog_idea_desc_promptTemp)
+    blog_idea_desc = blog_idea_desc_extraction_chain.run(blog_idea_desc_prompt)
+    
+    return blog_idea_desc
+

blog_ideas_generation.py

@@ -0,0 +1,15 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def blog_idea_gen(topic, llm):
+    
+    
+    blog_idea_prompt = f"Create a list of at least 10 blog post ideas on the following topic: {topic}. Suggest SEO-Friendly title and use an emotional and persuasive tone in blog post titles."
+    blog_idea_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are my blogger writter\n\n{text_input}\n\nSEO blog post ideas:")
+    blog_idea_extraction_chain = LLMChain(llm=llm, prompt=blog_idea_promptTemp)
+    blog_idea = blog_idea_extraction_chain.run(blog_idea_prompt)
+    
+    return blog_idea
+

blog_post_generation.py

@@ -0,0 +1,13 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def blog_post_gen(topic, llm):
+    
+    blog_post_prompt = f"Write a blog Plost about {topic}."
+    blog_post_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a Professional Content Creator and Blog Writer:\n{text_input}\nBlog Post:")
+    blog_post_extraction_chain = LLMChain(llm=llm, prompt=blog_post_promptTemp)
+    blog_post = blog_post_extraction_chain.run(blog_post_prompt)
+    
+    return blog_post

blog_post_tags_generation.py

@@ -0,0 +1,15 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def blog_tags_gen(blog, llm):
+    
+    
+    blog_tags_desc_prompt = f" Suggest at least 5 tags for the following blog post.\n{blog}"
+    blog_tags_desc_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are my blogger writter\n\n{text_input}\n\nSEO blog post ideas:")
+    blog_tags_desc_extraction_chain = LLMChain(llm=llm, prompt=blog_tags_desc_promptTemp)
+    blog_tags_desc = blog_tags_desc_extraction_chain.run(blog_tags_desc_prompt)
+    
+    return blog_tags_desc
+

email_marketing_campaigns_generation.py

@@ -0,0 +1,15 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def email_marketing_campaigns_gen(product_name, product_description, target_audience, goal, llm):
+    
+    email_prompt = f"Generate a high-converting email marketing campaign for {product_name}. {product_name} is {product_description}. that is targeted at {target_audience} and has the goal of {goal}. The campaign should include a welcome email, a nurture sequence, and a promotional email."
+        
+    email_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a Professional Email Marketing Copywriter:\n{text_input}\nEmail Marketing Campaign:")
+   
+    email_extraction_chain = LLMChain(llm=llm, prompt=email_promptTemp)
+    email = email_extraction_chain.run(email_prompt)
+    
+    return email

email_writer.py

@@ -0,0 +1,46 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+class email_writing:
+
+    def __init__(self, llm):
+        self.llm = llm
+
+    def email_gen(self, recipient, recipient_position, sender_name, position_sender, desc):
+        
+        email_prompt = f"Write a professional and well organized Email on {desc}.\nThe name of the Recipient is {recipient} and the recipient position is {recipient_position}.\nMy Name is {sender_name} and my Position is {position_sender}."
+            
+        email_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are a professional email writer:\n{text_input}\nEmail:")
+    
+        email_extraction_chain = LLMChain(llm=self.llm, prompt=email_promptTemp)
+        email = email_extraction_chain.run(email_prompt)
+        
+        return email
+
+    def email_subject_gen(self, email):
+
+        email_subject_prompt = f"Generate a subject for the following email:\n{email}\n"
+            
+        email_subject_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are a professional email writer:\n{text_input}\nEmail Subject:")
+    
+        email_subject_extraction_chain = LLMChain(llm=self.llm, prompt=email_subject_promptTemp)
+        email_subject = email_subject_extraction_chain.run(email_subject_prompt)
+        
+        return email_subject
+    
+    def email_marketing_campaigns_gen(self, product_name, product_description, target_audience, goal):
+    
+        email_prompt = f"Generate a high-converting email marketing campaign for {product_name}. {product_name} is {product_description}. that is targeted at {target_audience} and has the goal of {goal}. The campaign should include a welcome email, a nurture sequence, and a promotional email."
+            
+        email_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are a Professional Email Marketing Copywriter:\n{text_input}\nEmail Marketing Campaign:")
+    
+        email_extraction_chain = LLMChain(llm=self.llm, prompt=email_promptTemp)
+        email = email_extraction_chain.run(email_prompt)
+        
+        return email

facebook_ads_generation.py

@@ -0,0 +1,25 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def facebook_ads_gen(product_name, product_description, llm, tone_of_voice, targeted_audience="", plans_promotions=""):
+    
+    if targeted_audience != "" and plans_promotions != "":
+        facebook_ads_prompt = f"Generate a Facebook ad for {product_name} Product. {product_name} is {product_description}. Our Target Audience is {targeted_audience}. Our plans and promotions is {plans_promotions}. Tone of the ad should be {tone_of_voice}"
+
+    elif targeted_audience == "" and plans_promotions != "":
+        facebook_ads_prompt = f"Generate a Facebook ad for {product_name} Product. {product_name} is {product_description}. Our plans and promotions is {plans_promotions}. Tone of the ad should be {tone_of_voice}"
+    
+    elif targeted_audience != "" and plans_promotions == "":
+        facebook_ads_prompt = f"Generate a Facebook ad for {product_name} Product. {product_name} is {product_description}. Our Target Audience is {targeted_audience}. Tone of the ad should be{tone_of_voice}."
+    
+    else:
+        facebook_ads_prompt = f"Generate a Facebook ad for {product_name} Product. {product_name} is {product_description}. Tone of the ad Should be {tone_of_voice}."
+
+    facebook_ads_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a Professional Facebook Ad Copywriter:\n{text_input}\nFacebook Ad:")
+   
+    facebook_ad_extraction_chain = LLMChain(llm=llm, prompt=facebook_ads_promptTemp)
+    facebook_ad = facebook_ad_extraction_chain.run(facebook_ads_prompt)
+    
+    return facebook_ad

facebook_campaign.py

@@ -0,0 +1,33 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def facbook_camp_gen(product_name, product_desc, days, goal, llm):
+    
+    
+    facebook_ads_prompt = f"Generate a {days} days Facebook campaign (no budget included) calendar for our {product_name}. {product_name} is {product_desc}. with the goal to {goal}."
+    print(facebook_ads_prompt)
+    facebook_ads_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="""You are a Professional Facebook Digital Marketer:\n{text_input}\nGenerate only the Facebook campaign Calender without any details and don't mention any budgets:\nExample to emulate it:\nWeek 1: Getting Started and Teasers
+
+Day 1-2: Introduction to FAQGenius, share its features and benefits.
+Day 3-4: Teaser posts about how FAQGenius can save time and improve customer satisfaction.
+Day 5-7: User testimonials and success stories with FAQGenius." and so on..
+""")
+    facebook_ad_extraction_chain = LLMChain(llm=llm, prompt=facebook_ads_promptTemp)
+    facebook_ad = facebook_ad_extraction_chain.run(facebook_ads_prompt)
+    
+    return facebook_ad
+
+def social_media_camp_gen(product_name, product_desc, days, goal, llm):
+    
+    
+    facebook_ads_prompt = f"Generate a {days} days Social Media campaign (no budget included) calendar for our {product_name}. {product_name} is {product_desc}. with the goal to {goal}."
+    print(facebook_ads_prompt)
+    facebook_ads_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a Professional Social Media Marketer:\n{text_input}\nSocial Media Campaign:")
+    facebook_ad_extraction_chain = LLMChain(llm=llm, prompt=facebook_ads_promptTemp)
+    facebook_ad = facebook_ad_extraction_chain.run(facebook_ads_prompt)
+    
+    return facebook_ad

facebook_post_generation.py

@@ -0,0 +1,15 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def facebook_post_gen(tone_of_voice, topic, llm):
+    
+    productDesc_prompt = f"Write an attractive facebook post on {topic}. Tone should be {tone_of_voice}. Post dosen't include any photos or videos."
+        
+    productDesc_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a professional facebook content creator:\n{text_input}\n\nFacebook Post:")
+   
+    productDesc_extraction_chain = LLMChain(llm=llm, prompt=productDesc_promptTemp)
+    product_desc = productDesc_extraction_chain.run(productDesc_prompt)
+    
+    return product_desc

feather_chat.py

@@ -0,0 +1,65 @@
+from transformers import AutoTokenizer
+from langchain.chains import ConversationChain
+from langchain.llms import GooglePalm
+from langchain.memory import ConversationBufferMemory
+import os
+from dotenv import load_dotenv, find_dotenv
+import streamlit as st
+
+
+load_dotenv(find_dotenv())
+google_api_key = os.environ['GOOGLE_API_KEY']
+tokenizer = AutoTokenizer.from_pretrained("google/flan-ul2")
+
+def call_palm(google_api_key, temperature=0.5, max_tokens=8000, top_p=0.95, top_k=40, n_batch=9, repeat_penalty=1.1, n_ctx=8000):
+    
+        
+    google_palm_model = GooglePalm(
+        
+         google_api_key=google_api_key,
+         temperature=temperature,
+         max_output_tokens=max_tokens,
+         top_p=top_p,
+         top_k=top_k, 
+         n_batch=n_batch,
+         repeat_penalty = repeat_penalty,
+         n_ctx = n_ctx
+    )
+    
+    return google_palm_model
+    
+llm = call_palm(google_api_key)
+memory = ConversationBufferMemory()
+
+
+
+conversation_total_tokens = 0
+new_conversation = ConversationChain(llm=llm, 
+                                    verbose=False,
+                                    memory=memory, )
+
+current_line_number = 1
+while True:
+    
+    message = st.text_input('Human',  key = str(current_line_number))
+    
+    if message=='Exit':
+        
+        st.text(f"{conversation_total_tokens} tokens used in total in this conversation.")
+        break
+        
+    if message:
+        
+        formatted_prompt = new_conversation.prompt.format(input=message, history=new_conversation.memory.buffer)
+        st.text(f'formatted_prompt is {formatted_prompt}')
+
+        num_tokens = len(tokenizer.tokenize(formatted_prompt))
+        conversation_total_tokens += num_tokens
+        st.text(f'tokens sent {num_tokens}')
+
+        response = new_conversation.predict(input=message)
+        response_num_tokens = len(tokenizer.tokenize(response))
+        conversation_total_tokens += response_num_tokens
+        st.text(f"Featherica: {response}")
+
+    current_line_number = current_line_number + 1

idea_generation.py

@@ -0,0 +1,104 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+import re
+
+def ideas_generator(topic, keywords, llm, tone_of_voice='Professional', num_of_ideas=3):
+    
+    '''
+    Description:
+    
+        The ideas_generator() function designed to generate catchy short or long form article titles for a given topic, 
+        utilizing a set of specified keywords. 
+        This function employs a language model to create these titles, 
+        The function can produce either a single title or multiple titles based on the value of the num argument and supports both concise and informative title generation.
+    '''
+    
+    '''
+    Parameters:
+    
+        topic (str, required): The topic or subject matter of the article for which you want to generate titles.
+        keywords (str, required): A list of keywords that should be used to help generate catchy titles relevant to the topic. These keywords can provide context and improve the quality of the titles.
+        llm (langchain.llms object, required): An instance of a pre-trained language model (e.g., GPT-3 or GPT-4) that will be used to generate the titles. This model should be provided by the user.
+        num_of_ideas (int, optional): The number of long-form titles to generate. If num is set to 1, the function will produce a single title. If num is greater than 1, it will generate multiple titles. Default is 3.
+        tone_of_voice (str, optional): A String to determine the tone of voice of the title. Default Value Professional
+    '''
+    
+    '''
+    Returns:
+    
+        ideas (str): Functions returns a text with number of ideas numbered with roman numerals   
+    '''
+    
+    if num_of_ideas == 1:
+        
+            ideas_prompt = f"Generate only 1 {tone_of_voice} and catchy Innovation title for my article about {topic} topic.\n\nuse this keywords to help you generate {tone_of_voice} catchy title: {keywords}."
+
+    else:
+            ideas_prompt = f"Generate only {num_of_ideas} {tone_of_voice} and catchy Innovation titles for my article about {topic} topic.\n\nuse this keywords to help you generate {tone_of_voice} catchy titles: {keywords}."
+
+    ideas_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a professional content creator and Title Generator:\n\n{text_input}\n\n:Titles (number them with roman numerals):")
+
+    ideas_extraction_chain = LLMChain(llm=llm, prompt=ideas_promptTemp)
+    ideas = ideas_extraction_chain.run(ideas_prompt)
+
+    return ideas
+
+
+def filter_ideas(ideas):
+    
+    '''
+    Description:
+    
+        The filter_ideas() function extracts and filters article titles numbered with roman numerals from a given block of text. 
+        This function uses a regular expression to identify and extract these titles and returns them as a list of strings.
+    '''
+    '''
+    Parameters:
+    
+    ideas (str): A block of text that contain article titles formatted with Roman numerals and their corresponding content.
+    '''
+    
+    '''
+    Returns
+       filtered_ideas (list of str): A list of long-form article titles extracted from the input text.
+   '''
+    pattern =  r'\b[IVXLCDM]+\.\s*(.*?)(?:\n|$)'
+    filtered_ideas = re.findall(pattern, ideas)
+    
+    return filtered_ideas
+
+
+def pick_idea(list_ideas):
+    
+    """
+    Description:
+    
+        The pick_idea() function allows a user to choose one idea from a list of ideas. 
+        It presents the user with a numbered list of ideas and prompts them to select an idea by typing the corresponding number. 
+        The selected idea is then returned as the output of the function.
+    """
+    
+    """
+    Parameters:
+    
+        list_ideas (list of str): A list of ideas from which the user will choose one.
+    """
+    
+    """
+    Return:
+        
+        idea (str): The idea selected by the user from the list of ideas.
+    """
+    
+    print("Choose One Idea:\n")
+    
+    for counter, idea in enumerate(list_ideas):
+        c = counter+1
+        print(f"{c}. {idea}")
+        
+    x = int(input("Type the number of the idea: "))
+    idea = list_ideas[x-1]
+    
+    return idea

insta_image_caption_generation.py

@@ -0,0 +1,27 @@
+from transformers import pipeline
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def img2text(url):
+
+    image_to_text = pipeline("image-to-text", model='Salesforce/blip-image-captioning-base')
+
+    text = image_to_text(url)
+
+    out = text[0]['generated_text']
+    
+    return out
+
+
+def generate_InstaCap(scenario, tone_of_voice, form, llm):
+    
+    instaCap_prompt = f"Craft a {form} Caption on my Instagram Image  Here is the description of my Instagram Image: {scenario}.\nThe tone should be {tone_of_voice}"
+        
+    instaCap_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are infulencer:\n{text_input}\nInstagram Caption:")
+   
+    instaCap_extraction_chain = LLMChain(llm=llm, prompt=instaCap_promptTemp)
+    instaCap = instaCap_extraction_chain.run(instaCap_prompt)
+    
+    return instaCap

keywords_generation.py

@@ -0,0 +1,83 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+import re
+
+def keywords_generator(topic, llm, num_keywords=10):
+    
+    '''
+    Description: 
+    
+        Generates a list of keywords for a given topic using a large language model (LLM).
+    '''
+    
+    '''
+    Parameters:
+    
+        topic (str): Required Parameter -> The topic for which to generate keywords.
+        llm (langchain.llms object): Required Parameter -> The LLM to use for generating keywords.
+        num_keywords (int): Optional Parameter -> The number of keywords to generate. Default Value is 10
+        long_tail_keywords (bool): Optional Parameter -> A boolean flag indicating whether to generate long-tail keywords. Default Value is False
+    '''
+    
+    '''
+    Returns:
+        Keywords (str): A Text of list of keywords numbered with roman numerals for the given topic -> str datatype.
+    '''
+    
+    keywords_prompt = f"Identify {num_keywords} SEO keywords related to '{topic}'."
+
+    keywords_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a professional content creator and SEO Keywords Generator:\n\n{text_input}\n\nKeywords (number them with roman numerals):")
+
+    keywords_extraction_chain = LLMChain(llm=llm, prompt=keywords_promptTemp)
+    keywords = keywords_extraction_chain.run(keywords_prompt)
+
+    return keywords
+
+
+def filter_keywords(keywords):
+    '''
+    Description: 
+    
+        Filters keywords to extract the keywords that numbered with roman numerals using regx
+    '''
+    
+    '''
+    Parameters:
+
+        keywords (str): Required Parameter -> A Text of keywords Numbered with roman numerals to filter.
+    '''
+    
+    '''
+    Returns:
+    
+        filtered_keywords(list): A filtered list of keywords.
+    '''
+    
+    pattern = r'\b[IVXLCDM]+\.\s*(.*?)(?:\n|$)'
+    filtered_keywords = re.findall(pattern, keywords)
+    
+    return filtered_keywords
+
+
+def process_keywords(list_keywords):
+    
+    '''
+    Description: 
+        Formats a list of keywords into a comma-separated string.
+    '''
+    
+    '''
+    Parameters:
+
+        list_keywords (list):Required Parameters -> A list of keywords to format.    
+    '''
+    
+    '''
+    Returns:
+    
+        formatted_keywords (str): A comma-separated string of keywords.
+    '''
+    formatted_keywords = ", ".join(list_keywords)
+    return formatted_keywords

landing_page_generation.py

@@ -0,0 +1,13 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def landing_page_gen(product_name, product_desc, target_audience, goal, llm):
+    
+    landing_page_prompt = f"Generate a landing page content for {product_name}. {product_name} is {product_desc} that is targeted at {target_audience} and has the goal of {goal}. The landing page should be clear, concise, and persuasive. It should also include a call to action."
+    landing_page_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="{text_input}")
+    landing_page_extraction_chain = LLMChain(llm=llm, prompt=landing_page_promptTemp)
+    landing_page = landing_page_extraction_chain.run(landing_page_prompt)
+    
+    return landing_page

linkedIn_ads_generation.py

@@ -0,0 +1,15 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def linkedIn_ads_gen(product_name, product_desc, target_audience, target_keywords, llm):
+    
+    
+    linkedIn_ads_prompt = f"Generate a LinkedIn ad for {product_name}. {product_name} is {product_desc} that is targeted at {target_audience} and uses the keywords {target_keywords}. The ad should be persuasive and engaging, and it should include a call to action."
+
+    linkedIn_ads_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a Professional LinkedIn Ad Copywriter:\n{text_input}\nFacebook Ad:")
+    linkedIn_ad_extraction_chain = LLMChain(llm=llm, prompt=linkedIn_ads_promptTemp)
+    linkedIn_ad = linkedIn_ad_extraction_chain.run(linkedIn_ads_prompt)
+    
+    return linkedIn_ad

linkedin_post_generation.py

@@ -0,0 +1,15 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def linkedIn_post_gen(topic, tone_of_voice, llm):
+    
+    linkedIn_post_prompt = f"Write an engagging LinkedIn Post on {topic}. The tone should be {tone_of_voice}."
+        
+    linkedIn_post_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a content creator and LinkedIn Posts writer :\n{text_input}\nLinkedIn Post:")
+   
+    linkedIn_post_extraction_chain = LLMChain(llm=llm, prompt=linkedIn_post_promptTemp)
+    linkedIn_post = linkedIn_post_extraction_chain.run(linkedIn_post_prompt)
+    
+    return linkedIn_post

load_model.py

@@ -0,0 +1,86 @@
+from langchain.llms import GooglePalm, LlamaCpp
+
+def call_palm(google_api_key, temperature=0, max_tokens=8000, top_p=0.95, top_k=40, n_batch=9, repeat_penalty=1.1, n_ctx=8000):
+    
+    '''
+    desc:
+    
+        call_palm() is a fuction can be used to instantiate a Google Palm model. 
+        this model can be used to generate text, translate languages, write different kinds of creative content, and answer your questions in an informative way.
+    '''
+    
+    '''
+    Params and args:
+    
+        google_api_key (str): Required Parameter -> The Google API key for the Palm model.
+        temperature (float): Optional Parameter -> The temperature parameter controls the randomness of the generated text. A higher temperature will result in more creative and varied text, but it may also be less accurate.
+        max_output_tokens (int): Optional Parameter -> The maximum number of tokens to generate.
+        top_p (float): Optional Parameter -> The top_p parameter controls the diversity of the generated text. A higher top_p will result in more diverse text, but it may also be less coherent.
+        top_k (int): Optional Parameter -> The top_k parameter controls the number of tokens to consider when generating text. A higher top_k will result in more accurate text, but it may also be less creative.
+        n_batch (int): Optional Parameter -> The n_batch parameter controls the number of batches to use when generating text. A higher n_batch will result in faster generation, but it may also be less accurate.
+        repeat_penalty (float): Optional Parameter -> The repeat_penalty parameter controls the penalty for repeating tokens. A higher repeat_penalty will result in more diverse text, but it may also be less fluent.
+        n_ctx (int): Optional Parameter -> The n_ctx parameter controls the context length used to generate text. A higher n_ctx will result in more coherent text, but it may also be slower to generate.
+    '''
+    
+    '''
+    return:
+    
+         This function returns Google Palm as language model object. 
+         This object can be used to generate text, translate languages, write different kinds of creative content, and answer your questions in an informative way.
+    '''
+        
+    google_palm_model = GooglePalm(
+        
+         google_api_key=google_api_key,
+         temperature=temperature,
+         max_output_tokens=max_tokens,
+         top_p=top_p,
+         top_k=top_k, 
+         n_batch=n_batch,
+         repeat_penalty = repeat_penalty,
+         n_ctx = n_ctx
+    )
+    
+    return google_palm_model
+
+def call_llama2(model_path, temperature=0, max_tokens=8192, top_p=0.95, top_k=40, n_batch=9, repeat_penalty=1.1, n_ctx=8192):
+    
+    '''
+    desc:
+        call_llama() is a fuction can be used to instantiate a Meta llama-2 13B model. 
+        this model can be used to generate text, translate languages, write different kinds of creative content, and answer your questions in an informative way.
+    '''
+    
+    '''
+    Params and args:
+    
+        model_path (str): Required Parameter -> The path to the Llama model file.
+        temperature (float): Optional Parameter -> The temperature parameter controls the randomness of the generated text. A higher temperature will result in more creative and varied text, but it may also be less accurate.
+        max_tokens (int): Optional Parameter -> The maximum number of tokens to generate.
+        top_p (float): Optional Parameter -> The top_p parameter controls the diversity of the generated text. A higher top_p will result in more diverse text, but it may also be less coherent.
+        top_k (int): Optional Parameter -> The top_k parameter controls the number of tokens to consider when generating text. A higher top_k will result in more accurate text, but it may also be less creative.
+        n_batch (int): Optional Parameter -> The n_batch parameter controls the number of batches to use when generating text. A higher n_batch will result in faster generation, but it may also be less accurate.
+        repeat_penalty (float): Optional Parameter -> The repeat_penalty parameter controls the penalty for repeating tokens. A higher repeat_penalty will result in more diverse text, but it may also be less fluent.
+        n_ctx (int): Optional Parameter -> The n_ctx parameter controls the context length used to generate text. A higher n_ctx will result in more coherent text, but it may also be slower to generate.
+    '''
+    
+    '''
+    return:
+    
+         This function returns Meta llama-2 13B as language model object. 
+         This object can be used to generate text, translate languages, write different kinds of creative content, and answer your questions in an informative way.
+    '''
+    
+    llm = LlamaCpp(
+                model_path=model_path,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                top_p=top_p,
+                top_k=top_k, 
+                n_batch=n_batch, 
+                repeat_penalty=repeat_penalty,
+                n_ctx=n_ctx
+
+            )
+    
+    return llm

meta_content_creation.py

@@ -0,0 +1,94 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from transformers import pipeline
+
+class meta_content_generation:
+
+        
+    def __init__(self, llm):
+        self.llm = llm
+
+
+    def facebook_ads_gen(self, product_name, product_description, tone_of_voice, targeted_audience="", plans_promotions=""):
+    
+        if targeted_audience != "" and plans_promotions != "":
+            facebook_ads_prompt = f"Generate a Facebook ad for {product_name} Product. {product_name} is {product_description}. Our Target Audience is {targeted_audience}. Our plans and promotions is {plans_promotions}. Tone of the ad should be {tone_of_voice}"
+
+        elif targeted_audience == "" and plans_promotions != "":
+            facebook_ads_prompt = f"Generate a Facebook ad for {product_name} Product. {product_name} is {product_description}. Our plans and promotions is {plans_promotions}. Tone of the ad should be {tone_of_voice}"
+        
+        elif targeted_audience != "" and plans_promotions == "":
+            facebook_ads_prompt = f"Generate a Facebook ad for {product_name} Product. {product_name} is {product_description}. Our Target Audience is {targeted_audience}. Tone of the ad should be{tone_of_voice}."
+        
+        else:
+            facebook_ads_prompt = f"Generate a Facebook ad for {product_name} Product. {product_name} is {product_description}. Tone of the ad Should be {tone_of_voice}."
+
+        facebook_ads_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are a Professional Facebook Ad Copywriter:\n{text_input}\nFacebook Ad:")
+    
+        facebook_ad_extraction_chain = LLMChain(llm=self.llm, prompt=facebook_ads_promptTemp)
+        facebook_ad = facebook_ad_extraction_chain.run(facebook_ads_prompt)
+        
+        return facebook_ad
+    
+    def facbook_camp_gen(self, product_name, product_desc, days, goal):
+        
+        
+        facebook_ads_prompt = f"Generate a {days} days Facebook campaign (no budget included) calendar for our {product_name}. {product_name} is {product_desc}. with the goal to {goal}."
+        print(facebook_ads_prompt)
+        facebook_ads_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="""You are a Professional Facebook Digital Marketer:\n{text_input}\nGenerate only the Facebook campaign Calender without any details and don't mention any budgets:\nExample to emulate it:\nWeek 1: Getting Started and Teasers
+
+    Day 1-2: Introduction to FAQGenius, share its features and benefits.
+    Day 3-4: Teaser posts about how FAQGenius can save time and improve customer satisfaction.
+    Day 5-7: User testimonials and success stories with FAQGenius." and so on..
+    """)
+        facebook_ad_extraction_chain = LLMChain(llm=self.llm, prompt=facebook_ads_promptTemp)
+        facebook_ad = facebook_ad_extraction_chain.run(facebook_ads_prompt)
+        
+        return facebook_ad
+
+    def facebook_post_gen(self, tone_of_voice, topic):
+    
+        productDesc_prompt = f"Write an attractive facebook post on {topic}. Tone should be {tone_of_voice}. Post dosen't include any photos or videos."
+            
+        productDesc_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are a professional facebook content creator:\n{text_input}\n\nFacebook Post:")
+    
+        productDesc_extraction_chain = LLMChain(llm=self.llm, prompt=productDesc_promptTemp)
+        product_desc = productDesc_extraction_chain.run(productDesc_prompt)
+        
+        return product_desc
+
+    def img2text(self, url):
+
+        image_to_text = pipeline("image-to-text", model='Salesforce/blip-image-captioning-base')
+
+        text = image_to_text(url)
+
+        out = text[0]['generated_text']
+        
+        return out
+
+
+    def generate_InstaCap(self, scenario, tone_of_voice, form):
+        
+        instaCap_prompt = f"Craft a {form} Caption on my Instagram Image Here is the description of my Instagram Image: {scenario}.\nThe tone should be {tone_of_voice}"
+            
+        instaCap_promptTemp = PromptTemplate(
+        input_variables=["text_input"],
+        template="You are infulencer:\n{text_input}\nInstagram Caption:")
+    
+        instaCap_extraction_chain = LLMChain(llm=self.llm, prompt=instaCap_promptTemp)
+        instaCap = instaCap_extraction_chain.run(instaCap_prompt)
+        
+        return instaCap
+        
+    
+    
+
+
+

outline_generation.py

@@ -0,0 +1,67 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+import re
+from remove_astricks import remove_ast
+
+
+def outlines_generator(idea, keywords, llm):
+    
+    '''
+    Description:
+    
+        The outlines_generator() function  designed to generate an outline for an article based on a given idea and a set of keywords. 
+        The function leverages an LLM model to create a structured outline with section headings. 
+    '''
+    
+    '''
+    Parameters:
+    
+        idea (str): The main idea or topic of the article for which you want to generate an outline.
+        keywords (str): A set of keywords or topic-related terms that will be used as section headings in the outline. These headings help organize the content and provide a structure for the article.
+        llm (langchain.llms object): An instance of a pre-trained language model (e.g., Google Palm or llama2) that will be used to generate the article outline.
+    '''
+    
+    '''
+    Returns:
+    
+        outlines (str): The generated outline for the article, including section headings and placeholders for content under each heading.
+    '''
+    
+    outlines_prompt = f"Generate an table of contents with at least 10 main points for an article on {idea}. Include key points related to {keywords}.\nBe creative and innovation in each main topic"
+            
+    outlines_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a content creator\n{text_input}\n\nTable of Content (number each main point with roman numerals):")
+   
+    outlines_extraction_chain = LLMChain(llm=llm, prompt=outlines_promptTemp)
+    outlines = outlines_extraction_chain.run(outlines_prompt)
+    
+    return outlines
+
+
+def filtered_outlines(outline):
+    
+    '''
+    Description:
+        This function processes an outline text containing Roman numeral formatted section headers, 
+        splitting the input into sections and filtering out asterisks ('*') within each section. 
+        The resulting output is a list of cleaned outline sections.
+   
+    Parameters:
+        outline (str) -> Required: The input outline text containing Roman numeral formatted section headers.
+        
+    Return:
+        outline_list (list): A list containing cleaned sections of the input outline, with asterisks removed.
+    '''
+
+    sections = re.split(r'\b[IVXLCDM]+\.\s', outline)[1:]
+    sections = [f"{i}. {section}" for i, section in enumerate(sections, start=1)]
+
+    outline_list = []
+
+    for section in sections:
+        cleaned_section = remove_ast(section)
+        outline_list.append(cleaned_section)
+
+    return outline_list
+

product_description_generation.py

@@ -0,0 +1,33 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def product_description_gen(product_name, product_desc, tone_of_voice, llm):
+    
+    '''
+    Description:
+        This function generates an engaging product description based on user-provided inputs. 
+        It utilizes the LangChain library to prompt an AI model (Language Model) to create a product description tailored to the specified product name, description, tone of voice, and a provided LLM (Long Language Model).
+    '''
+
+    '''
+    Parameters:
+        product_name (str) -> Required: The name of the product for which the description is generated.
+        product_desc (str) -> Required: A brief description of the product.
+        tone_of_voice (str) -> Required: The intended tone of the product description (e.g., professional, friendly, persuasive).
+        llm -> Required: The Long Language Model (LLM) used for generating the description.
+    '''
+
+    '''
+    Return Value:
+        product_desc (str): The generated Amazon product description.
+    '''
+    productDesc_prompt = f"Write an engagging and {tone_of_voice} Amazon product description of {product_name} Product here is a short description of my product:\n\n{product_desc}\n"
+        
+    productDesc_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a content creator and product description writer who helps clients to write their product description on amazon:\n{text_input}\nAmazon Product Description:")
+   
+    productDesc_extraction_chain = LLMChain(llm=llm, prompt=productDesc_promptTemp)
+    product_desc = productDesc_extraction_chain.run(productDesc_prompt)
+    
+    return product_desc

remove_astricks.py

@@ -0,0 +1,5 @@
+import re
+
+def remove_ast(text):
+    cleaned_text = re.sub(r'\*', '', text)
+    return cleaned_text

workout_plan_generation.py

@@ -0,0 +1,26 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def workout_plan_gen(my_goals, fitness_level, days, hours, helth_cosnd, routine, llm):
+    
+    
+    
+
+    workout_plan_prompt = f"""Generate a workout plan with diversity and creative exercises.
+Please note the following details:
+* My Goals: I'm looking to {my_goals}
+* Fitness Level: {fitness_level}.
+* Available Equipment: I have access to a gym with various equipment.
+* Time Commitment: I'm dedicated to working out {days} days a week, and I have {hours} hours a day I can spend during each session.
+* Health Considerations: I'm in the {helth_cosnd}.
+* Preferred Routine: I like to follow {routine} routine.\nWorkout Plan:"""
+        
+  
+
+    workout_plan_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a Professional Fitness Trainer:\n{text_input}")
+    workout_plan_extraction_chain = LLMChain(llm=llm, prompt=workout_plan_promptTemp)
+    workout_plan = workout_plan_extraction_chain.run(workout_plan_prompt)
+    
+    return workout_plan

x_bio_creation.py

@@ -0,0 +1,15 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def x_bio_gen(info, tone_of_voice, llm):
+    
+    x_bio_prompt = f"Craft a personalized Twitter bio for me, based on the content I create, related to {info}. tone should be {tone_of_voice}, Produce 10 tailor-made Twitter bios for me."
+    x_bio_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a copywriter\n{text_input}\n\nTwitter Bios:")
+    x_bio_extraction_chain = LLMChain(llm=llm, prompt=x_bio_promptTemp)
+    x_bio = x_bio_extraction_chain.run(x_bio_prompt)
+    
+    return x_bio
+
+

x_campaign_generation.py

@@ -0,0 +1,15 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def x_camp_gen(product_name, product_desc, goal, llm):
+    
+    
+    x_camp_prompt = f"Design a potent Twitter campaign for my product '{product_name}'. {product_name} is {product_desc} aiming to accomplish {goal} through the meticulous adoption of planning and content creation best practices.\n\nCampaign will include: Campaign Teaser, Educational Content Series, Customer Testimonials and Case Studies, Interactive Content, Limited-Time Offer Announcement, Call-to-Action for Consultation and  Recap and Thank You."
+    print(x_camp_prompt)
+    x_camp_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a Specialist in Twitter Copywriting\n\n{text_input}\n\nMake the tweets engaging, creative and coherent")
+    x_camp_extraction_chain = LLMChain(llm=llm, prompt=x_camp_promptTemp)
+    x_camp = x_camp_extraction_chain.run(x_camp_prompt)
+    
+    return x_camp

x_retweet_commenting_generation.py

@@ -0,0 +1,15 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def x_retweet_commenting_gen(tweet, tone_of_voice, llm):
+    
+    x_retweet_comment_prompt = f"I'm planning to retweet the following tweet:\n“{tweet}”\nConstruct 5 varied comments I could append to this retweet. tone should be {tone_of_voice}"
+    x_retweet_comment_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are Specilaized Twitter Copywriter\n{text_input}\n\nRetweet Comment:")
+    x_retweet_comment_extraction_chain = LLMChain(llm=llm, prompt=x_retweet_comment_promptTemp)
+    x_retweet_comment = x_retweet_comment_extraction_chain.run(x_retweet_comment_prompt)
+    
+    return x_retweet_comment
+
+

x_thread_generation.py

@@ -0,0 +1,29 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def X_thread_gen(topic, num_tweets, tone_of_voice, llm):
+    
+    X_thread_prompt = f"Write a an engagging Twitter Thread  on '{topic}' consists of {num_tweets} tweets. Tone should be {tone_of_voice}"
+        
+    X_thread_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a Twitter Content Creator:\n{text_input}\n\nTwitter Thread:")
+   
+    X_thread_extraction_chain = LLMChain(llm=llm, prompt=X_thread_promptTemp)
+    X_thread = X_thread_extraction_chain.run(X_thread_prompt)
+    
+    return X_thread
+
+
+def X_thread_gen_intro(topic, thread, tone_of_voice, llm):
+    
+    X_thread_prompt = f"Write a an engagging and attractive Introduction head tweet for my twitter thread on {topic}. here is my twitter thread:\n{thread}\nTone should be {tone_of_voice}"
+        
+    X_thread_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="You are a Twitter Content Creator:\n{text_input}\n\nTweet:")
+   
+    X_thread_extraction_chain = LLMChain(llm=llm, prompt=X_thread_promptTemp)
+    X_thread = X_thread_extraction_chain.run(X_thread_prompt)
+    
+    return X_thread

youtube_ideas.py

@@ -0,0 +1,13 @@
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+def landing_page_gen(brand, customer, action, llm):
+    
+    landing_page_prompt = f"Generate a YouTube video idea that will provide a behind-the-scenes look at my {brand} and persuade my {customer} to take {action} with a sense of authenticity and relatability."
+    landing_page_promptTemp = PromptTemplate(
+    input_variables=["text_input"],
+    template="{text_input}")
+    landing_page_extraction_chain = LLMChain(llm=llm, prompt=landing_page_promptTemp)
+    landing_page = landing_page_extraction_chain.run(landing_page_prompt)
+    
+    return landing_page