Upload 16 files

.env

@@ -0,0 +1 @@
+OPENAI_API_KEY = 'sk-proj-i6hkOW8E1LXn4N49xH3eT3BlbkFJUQbMtVJTTSHhcLAlAx14'

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+video.mp4 filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,26 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    pandoc \
+    libgl1-mesa-glx \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create a non-root user and switch to it
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file and install dependencies
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copy the rest of the application files
+COPY --chown=user . /app
+
+# Define the command to run the Streamlit application
+CMD ["streamlit", "run", "app.py", "--server.port", "8501", "--server.enableCORS", "false"]

agents.py

@@ -0,0 +1,188 @@
+from crewai import Agent, Task
+from tools import scrape_website, generate_images_and_add_to_blog, generate_video
+# from langchain_groq import ChatGroq
+from langchain_openai import ChatOpenAI
+from utils import post_image_and_text
+
+def get_agents_and_tasks(is_token):
+
+    # llm = ChatGroq(model="llama3-70b-8192", api_key=groq_api_key)
+    llm = ChatOpenAI(model='gpt-4o-mini')    
+
+    information_retriever_agent = Agent(
+        role="Web Information Retriever",
+        goal="To retieve all the information from the website and summarize the information.",
+        backstory="You are web information retriever agent. You are expert in scraping websites and summarizing the content.",
+        verbose=True,
+        llm=llm,
+        allow_delegation=False
+    )
+
+    task_scrape = Task(
+        description="Scrape all the informatin from the website: {website}.",
+        expected_output="Scraped information from the website: {website}",
+        agent=information_retriever_agent,
+        tools=[scrape_website]
+    )
+
+    task_summarize = Task(
+        description="provide a neet summary of the company. Do not add up things. ",
+        expected_output="Detailed summary of a company web page. "
+        # "Start with Company name, Mission and Vision, Leadership. "
+        # "Explain it's Products and Services, Market presence, Financial highlights, Recent Developments and Future plans. "
+        # "If there are not mentioned, explain they have mentioned."
+        "Do not add up things.",
+        agent=information_retriever_agent,
+        context=[task_scrape]
+    )
+
+    blog_agent = Agent(
+        role="Blog Writer",
+        goal="Create captivating blog that inspire and educate readers.",
+        backstory="You are a skilled blog writer for a company, creating insightful and engaging blog posts on various topics. You have a passion for sharing knowledge through writing. With years of experience in the industry, you know how to craft compelling narratives and provide valuable insights to your audience.",
+        verbose=True,
+        llm=llm,
+        allow_delegation=False
+    )
+
+    task_create_blog = Task(
+    description=
+        "Write a compelling blog on the topic '{topic}' for the company."
+        "Begin by explaining the topic, followed by an introduction to the company. Do not add up things. "
+        # "In the second half of blog, include a brief mention of the company to highlight its relevance to the topic. "
+        "The blog should cover various aspects relevant to {topic}, ensuring it provides comprehensive insights and value to the readers. "
+        "The blog should contain 2 image, so insert '<-IMAGE->' where image has to be inserted. One image should be after first paragraph. "
+        "The blog should not contain author details.",
+    expected_output="A full engaging and informative blog post about the topic: '{topic}'",
+    # output_file="topic_blog_post.md",
+    agent=blog_agent,
+    context=[task_summarize]
+    )
+
+    task_visual_prompts = Task(
+        description = "Replace <-IMAGE-> with prompts.There should be 2 images in the blog. "
+        "Every prompt should be enclosed in '<image> prompt </image>' tag. "
+        "The image should not contain any form of text, names of persons, company or company logo, etc.  "
+        "Prompt is 'What you wish to see in the output image'. "
+        "A descriptive prompt that clearly defines elements, colors, and subjects will lead to better results. "
+        # "To control the weight of a given word use the format (word:weight), where word is the word you'd like to control the weight of and weight is a value between 0 and 1. "
+        "For example: The sky was a crisp (blue:0.3) and (green:0.8) would convey a sky that was blue and green, but more green than blue. The weight applies to all words in the prompt. ",
+        # "Image should not contain names of persons, company or company logo, etc. ",
+        expected_output= "A full blog with prompts enclosed in '<image> prompt </image>' tag.",
+        agent = blog_agent,
+        context = [task_create_blog]
+    )
+
+    task_add_images = Task(
+        description = "Generate images and add to blog using the provided tool. If image generation fails, stop the execution.",
+        expected_output= "A full blog with images.",
+        agent = blog_agent,
+        # output_file="blog_post.md",
+        tools = [generate_images_and_add_to_blog],
+        context = [task_visual_prompts]
+    )
+
+    content_creation_agent = Agent(
+        role="Content Creator",
+        goal="To generate accurate and engaging narration and image prompt pairs for video scripts and subsequently generate videos using these pairs.",
+        backstory="The agent is designed to assist in creating engaging video content by generating narrations and image prompts, and then compiling them into videos.",
+        verbose=True,
+        llm=llm,
+        allow_delegation=False
+    )
+
+    # task_summarize_blog = Task(
+    #     description = "Summarize the blog into two to three paragraphs.",
+    #     #   focusing on the topic: '{topic}'. "
+    #     #  "Ensure the summary is concise yet comprehensive, capturing the essence of the '{topic}' and its significance. ",
+    #     expected_output = "Two to three paragraphs of summary of the blog, mainly focussed on '{topic}'. ",
+    #     agent = content_creation_agent,
+    #     context = [task_visual_prompts]
+    # )
+
+    # task_video_script = Task(
+    #     description = "Write a script for video about the topic: {topic}. Remember to use context as just reference, do not use context as script.",
+    #     expected_output = "Two to three paragraphs of script for the video, mainly focussed on '{topic}'. ",
+    #     agent = content_creation_agent,
+    #     context = [task_visual_prompts]
+    # )
+
+    task_generate_narration_image_pairs = Task(
+    description = "Generate narration and image prompt pairs for video script about the topic: '{topic}'. The number of pairs are limited to two. Total words in narration should be less than 100."
+    "Image should not contain any form of text, names of persons, company or company logo, etc. "
+    "Prompt is 'What you wish to see in the output image'. "
+    "A descriptive prompt that clearly defines elements, colors, and subjects will lead to better results. "
+    "To control the weight of a given word use the format (word:weight), where word is the word you'd like to control the weight of and weight is a value between 0 and 1. "
+    "For example: The sky was a crisp (blue:0.3) and (green:0.8) would convey a sky that was blue and green, but more green than blue. The weight applies to all words in the prompt. ",
+    # "Image should not contain names of persons, company or company logo, etc. ",
+    expected_output="Pairs of sentences. Narrations are enclosed in <narration> narration here </narration> tag. Image prompts are enclosed in <image> image prompt here </image> tag.",
+    agent=content_creation_agent,
+    # context = [task_video_script]
+    )
+
+    task_generate_video = Task(
+        description="Generate video using narration and image prompt pairs. If image generation fails, stop the execution.",
+        expected_output="Path of the video",
+        agent=content_creation_agent,
+        context = [task_generate_narration_image_pairs],
+        tools=[generate_video]
+    )
+
+    LinkedInPosterAgent = Agent(
+    role="LinkedIn Poster",
+    goal="To post articles on LinkedIn",
+    backstory="This agent is responsible for automating the posting of articles on LinkedIn to keep the profile active and engaging.",
+    verbose=True,
+    llm=llm,
+    allow_delegation=False
+    )
+
+    BlogtoArticle = Task(
+        description="Convert the blog into engaging LinkedIn post of 150 words. " 
+        "Make the post attractive using emojis and symbols ."
+        "Use one image from blog for LinkedIn post",
+        expected_output="A dictionary containing image_path, post_content. ",
+        agent=LinkedInPosterAgent,
+        context = [task_add_images]
+    )
+
+    PostArticleToLinkedIn = Task(
+        description="""post article on LinkedIn.
+
+        token:
+
+        {token}
+        
+        """,
+        expected_output="A confirmation that the article was successfully posted on LinkedIn.",
+        agent=LinkedInPosterAgent,
+        context = [BlogtoArticle],
+        tools=[post_image_and_text]
+    )
+
+    agents = [
+              information_retriever_agent, 
+              blog_agent, 
+              content_creation_agent,
+              ]
+    
+    tasks = [
+             task_scrape, 
+             task_summarize, 
+             task_create_blog,
+             task_visual_prompts, 
+             task_add_images, 
+            # task_summarize_blog,
+            # task_video_script,
+             task_generate_narration_image_pairs, 
+             task_generate_video,
+             
+            ]
+    
+    if is_token:
+        agents.append(LinkedInPosterAgent)
+        tasks.append(BlogtoArticle)
+        tasks.append(PostArticleToLinkedIn)
+    
+    return agents, tasks
+

blog_post.md

@@ -0,0 +1,54 @@
+**Marketing Case Study: Unveiling the Success Behind DIGIOTAI's Digital Transformation**
+
+In today's rapidly evolving digital landscape, effective marketing strategies are paramount for businesses seeking to establish a competitive edge. One way to understand the intricacies and impact of marketing is through detailed case studies that provide actionable insights. This blog delves into a marketing case study, focusing on DIGIOTAI, a digital transformation (DX) enablement partner that empowers companies globally with advanced digital solutions.
+
+![](C:\Users\prudh\AppData\Local\Temp\tmpwwn2flpx.png)
+
+**Introduction to DIGIOTAI**
+
+DIGIOTAI stands as a beacon of innovation, facilitating digital transformation for reputed entities worldwide. With a mission to enable companies to thrive in the digital economy, DIGIOTAI offers a suite of services including IoT & Mobility, Data Science, Blockchain, AI/GenAI, AR/VR/MR, and Cloud Enablement. The company's prowess in delivering customized, integrated solutions has made it a trusted partner for businesses across various industries.
+
+**Understanding the Marketing Case Study**
+
+A marketing case study is a comprehensive analysis of how a company or brand implemented a marketing strategy to achieve its business objectives. It covers the challenges faced, the strategies employed, the execution process, and the results obtained. For DIGIOTAI, the marketing case study revolves around their successful campaigns and initiatives that have significantly impacted their market presence and client engagement.
+
+**Key Aspects of DIGIOTAI's Marketing Strategy**
+
+1. **Target Audience Identification:**
+   DIGIOTAI's marketing team meticulously identified their target audience, focusing on industries such as Manufacturing, Automotive, Logistics & Supply Chain, Energy & Utilities. This targeted approach ensured that their marketing efforts were directed towards businesses that would benefit the most from their services.
+
+2. **Content Marketing:**
+   Leveraging rich content such as blogs, case studies, eBooks, and white papers, DIGIOTAI positioned itself as a thought leader in the digital transformation space. This not only educated their audience but also built trust and credibility.
+
+3. **Use of Advanced Technologies:**
+   The integration of AI and Data Science in their marketing strategies enabled DIGIOTAI to analyze market trends, customer behavior, and campaign performance with precision. This data-driven approach allowed for continuous optimization of their marketing efforts.
+
+4. **Strategic Partnerships:**
+   Forming alliances with other tech leaders and open-source communities, DIGIOTAI expanded its reach and enhanced its service offerings. These partnerships played a crucial role in amplifying their marketing message and establishing a robust network.
+
+5. **Customer-Centric Approach:**
+   By focusing on delivering exceptional value and personalized experiences, DIGIOTAI ensured high customer satisfaction and loyalty. Their marketing campaigns highlighted real-world benefits and success stories, making their solutions relatable and attractive to potential clients.
+
+**Results and Achievements**
+
+The implementation of these marketing strategies yielded remarkable results for DIGIOTAI. They witnessed a significant increase in their client base, enhanced brand recognition, and improved market penetration. Their tailored solutions and innovative approach resonated well with their target audience, leading to successful digital transformation projects across various sectors.
+
+![](C:\Users\prudh\AppData\Local\Temp\tmpidgx13ew.png)
+
+**Conclusion**
+
+The marketing case study of DIGIOTAI showcases the power of a well-crafted and executed marketing strategy in driving business success. By understanding their audience, leveraging advanced technologies, forming strategic partnerships, and maintaining a customer-centric approach, DIGIOTAI not only achieved its business goals but also set a benchmark in the digital transformation industry. 
+
+This case study serves as an inspiring example for other businesses aiming to navigate the complexities of the digital economy and underscores the importance of strategic marketing in achieving sustainable growth.
+
+**Explore More with DIGIOTAI**
+
+To learn more about DIGIOTAI's innovative solutions and how they can help your business thrive in the digital era, visit their website and explore their extensive range of services and resources. Stay updated with the latest trends and insights by subscribing to their newsletter.
+
+**Join the Digital Transformation Journey with DIGIOTAI**
+
+Embrace the future of business with DIGIOTAI's cutting-edge digital solutions. Connect with their team today and start your journey towards unparalleled digital excellence.
+
+---
+
+This comprehensive blog post aims to provide valuable insights into the marketing strategies employed by DIGIOTAI, offering readers a clear understanding of the methodologies that led to their success.

packages.txt

@@ -0,0 +1,2 @@
+pandoc
+libgl1-mesa-glx

requirements.txt

@@ -0,0 +1,22 @@
+pysqlite3-binary
+embedchain
+crewai
+crewai-tools
+langchain-openai
+streamlit
+gtts
+pydub
+groq
+Pillow
+sendgrid
+moviepy
+requests
+pypandoc
+opencv-python-headless
+opencv-python
+numpy
+openai
+google-api-python-client
+google-auth
+google-auth-oauthlib    
+google-auth-httplib2

service_account.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "lithe-climber-430405-c1",
+  "private_key_id": "62057d717771d86af720216847c6e84c4b59660a",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDNU0o022lo79iL\noyHzX7Q1GSQ+ZBje99sAvn4v1XE91zQVbtS+tzgnd4ixnyMZ1setkwo4FENOCS9+\nvhDt+MxbrVVFp2wNVyvyFi0/a2MZl9NRfBqDH6W+/zDgcTdHKCUDMRV77PBWESrm\n6rQKpWwNkQPFeJEDALESMvkDbhQ0mLfiEyDa8TNdhNDCvtl8QN5HLeQ8q9ZJXNml\nN8zFpSOSugr83tU6SO4neCixSS2g/02Hz4bjf5L5jzVVBF+tvxlly7rWMGhrL7Q5\nm/F/c8l2ArNZgLHlOG1OoND5HPY9aq9V2HCB55Hl17ChE974rGT0QTBvyQFCgLxS\nuFHpE/VpAgMBAAECggEAGl5ectBUxrm6rSArrYY2bfVHHs4bFZNuKDfOm9UFAISh\nNzlvD/kWuJbU0r7Vsq1PIn72OoJ7rEtospW1NeKUWBe4EkRwj3wI9EOd1v2zEefa\nJyZRf1Jypkc+nyxbBYPl0PWeRTaGHP+Ca3pr2cwpxso/Wj5kHScbFnO+YA7kgGZ7\nnIQQlCrLHcvIxA6OswnYrkzLGU1BxAml58iRtswggElLacWRys/8yubrjrN/djNj\nMjB81ymBlsgsiN21W8D/RU4u8NNIRGPyaeNCYeZne11AZmTmjMKeDMxIj/MD6bIT\nQkEOVLagRuImbi2G83/GAFdJdQnEh7EvV52+if/OwwKBgQDqIkj797j0RHVTcPwF\npceaUs338VmhZTC/nBbdSSiL8Av6HtHqvdFclB/IwiUsu5xNI++xAfI+SKGIVNYg\nAsQSwkzyICulorcbAQ+0o1XMBxI3RzzTXDleJ6dCGhZ6X4TGRJOdJ2OMGlHcVbBl\n/CA7IgKrTRHaSbW46rnbiKp56wKBgQDggD6LgW9Kp0aOfooX0My0z3MuAYzohZhP\nV7HyKr9RIf6C5YiOjlvPefTK488PhTMF0S964r4z0UDLVwMgZqOjhHjMuciQXNIe\nvSiCW0eSpfSkx4HvjFota095PO8JdtEu2RSBqXplaKgF5MuRp0iMLz+6R0jMnvtf\n2Qyd1aRE+wKBgD/Ma9rM28cjyFyeUu4vCD7TBXDkgSnraucrX0eZIcVP+dOEBmtS\nofP6INcRoBOaY7LZcfznrNyv6eQ+ScKbPlZmP5VSktIljoN7PI5aW4ym+J27eaWW\nYcN4RqlKdomN8Z4dHaQbEZMhsOC7ML/5fcbfM5799zlmEHB89XwOt3VVAoGAb30A\nkoMq46YCkg0hQwZ8QmarSnOWqHp/0xc31Y2JCR+apyKaGEF2Mqjb+k37rDd3yTHD\nJIGp9025ocGKWfLe3PuSigjRI3AVIRLLJUFzX85umc5CJtZKije6dfjetJJ++4bu\neh3SHL5GgvbGaYTrsEJeoYF5E7T4HPdLHq7ULzUCgYBAtNHW2+xWvVCg08O6fiJP\nPaFlMf+aW+F7x5eWdz+h1r/L3EqK/Wd+BFHq3oj/18Qe9zQQlU1S/FHGMmmTezod\ncxV6bb7uVOG6dY2XSzngB2mF43Zk7VVdro6V2NnnqZ9zBCciSzRI5UX3/R9Kuo/S\nvahSzKojgxdWAgtcAkW6LA==\n-----END PRIVATE KEY-----\n",
+  "client_email": "[email protected]",
+  "client_id": "106218391187943604877",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/digiotai-ai%40lithe-climber-430405-c1.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

streamlit_app.py

@@ -0,0 +1,61 @@
+from agents import get_agents_and_tasks
+from crewai import Crew
+from utils import send_email_with_company_details, post_image_and_text
+import streamlit as st
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# groq_api_key = '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'
+
+def generate_bolg_and_video(title, url, token):
+
+    if token is not None:
+        agents, tasks = get_agents_and_tasks(is_token=True)
+    else:
+        agents, tasks = get_agents_and_tasks(is_token=False)
+    
+    print(agents, '\n', tasks)
+
+    crew = Crew(
+        agents=agents,
+        tasks= tasks,
+        verbose = 2,
+    )
+
+    pairs = crew.kickoff(inputs={'topic':title, 'website':url, 'token':token})
+    print(1)
+
+    return 'video.mp4'
+
+st.title("Blog and Video Generator")
+
+title = st.text_input("Title")
+url = st.text_input("Website URL")
+email = st.text_input("Email ID")
+
+# token = 'AQXZFWxVIyE0IJ3vopgzsuG0t4uSg9lUnVwLOTLOkEOKIU9hhswEYXOpEzEveBFCZdcRP4B3vN8gd_HI920LTH5LFbO9TVkHbtn8P2qE_GcwBq_1LzGw-HwatIY3zU7auWhxCMVYAXsklAJx6FAa_Sx_MUtaVcnA42K1vhYxSS7s0ecQq0Thsdod1KrK2_nA0YjMc1lSnQQy1WDiK0HGN2-2jbDt13NpJTkmZqEWm6G9BRplTkUSeSSqGNuLEGpuY0hd50GcRovkcqpz9ZfvqkeiKhAYPPDTAGDX7HO5VjtHTui3ZCFEXvEbAHzng116xDfNnBE8-fsig7c9HP6c06UmmN6evA'
+
+token = None
+if st.checkbox(label='post on linkedIn'):
+    token = st.text_input('Enter you LinkedIn access token')
+
+
+
+if st.button("Generate"):
+    if title and url and email:
+
+        st.success("Blog and Video will be sent to your email.")
+        video_path = generate_bolg_and_video(title, url, token)
+        # st.write(video_path)
+
+        # with open('blog_post.md', 'r', encoding='latin-1') as f:
+        #     blog = f.read()
+        #     st.markdown(blog)
+        # st.video(video_path)
+
+        send_email_with_company_details(email, 'DIGIOTAI SOLUTIONS', title)
+        
+
+    else:
+        st.error("Please provide all inputs.")

token.json

@@ -0,0 +1 @@
+{"token": "ya29.a0AXooCgtRt0YL19FiMHwf1UzqHNlOF0CEgQxJ-lbjy5UXqg-CsRhIx2HZmalHUZLtkGnfI8KB_eKxttDVz9y05HYhIaqQYawwHVfF2AJ9SeEP7f7C-QmSxEarLEQ4WQ1T-eNJijTFjlZvoRgoRt21FE3K6fsKM89odWntgAaCgYKAaoSARASFQHGX2Mit0KJz3qesS_Bb4IpffHDJg0173", "refresh_token": "1//0gh5ZW3LeAPZHCgYIARAAGBASNwF-L9IrfG7kpoExwP30CVArRQebwQ3aXDxBdNWpuTrjd4BWTs0pLLrDj69_rRDZHDuo6bT297A", "token_uri": "https://oauth2.googleapis.com/token", "client_id": "576447402194-q30hgo3vttv2o98ajrm0b7qqgm9mpe7k.apps.googleusercontent.com", "client_secret": "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", "scopes": ["https://www.googleapis.com/auth/gmail.send"], "universe_domain": "googleapis.com", "account": "", "expiry": "2024-07-25T12:32:35.732138Z"}

tools.py

@@ -0,0 +1,627 @@
+from langchain.tools import tool
+from crewai_tools import ScrapeWebsiteTool
+from gtts import gTTS
+from pydub import AudioSegment
+from groq import Groq
+from PIL import Image, ImageDraw, ImageFont
+from moviepy.editor import VideoFileClip, AudioFileClip, concatenate_videoclips, ImageClip
+import requests
+import os
+import tempfile
+import re
+import base64
+import pypandoc
+import cv2
+import numpy as np
+import warnings
+warnings.filterwarnings('ignore')
+
+from pathlib import Path
+from openai import OpenAI
+
+# !sudo apt-get install pandoc
+
+
+@tool
+def scrape_website(website_url):
+    """Scrapes all the information from the given website.       
+    Args:
+        website_url: A url of a company website.
+    Returns:
+        Scraped information from the given website.
+    """
+    scrapper = ScrapeWebsiteTool()
+    data = scrapper.run(website_url=website_url)
+
+    return data
+
+def convert_md_to_docx(md_file_path, docx_file_path):
+    output = pypandoc.convert_file(md_file_path, 'docx', outputfile=docx_file_path)
+    assert output == "", "Conversion failed"
+    print(f"Converted {md_file_path} to {docx_file_path}")
+
+# def generate_image(text, num):
+#     engine_id = "stable-diffusion-v1-6"
+#     api_host = os.getenv('API_HOST', 'https://api.stability.ai')
+#     api_key = 'sk-5VTo97D19Ruf2zLinj3pQbVXmLmh2Ps354PGkufTHtqmB2BN'
+#     if api_key is None:
+#         raise Exception("Missing Stability API key.")
+    
+#     response = requests.post(
+#         f"{api_host}/v1/generation/{engine_id}/text-to-image",
+#         headers={
+#             "Content-Type": "application/json",
+#             "Accept": "application/json",
+#             "Authorization": f"Bearer {api_key}"
+#         },
+#         json={
+#             "text_prompts": [
+#                 {
+#                     "text": text
+#                 }
+#             ],
+#             "cfg_scale": 7,
+#             "height": 512,
+#             "width": 512,
+#             "samples": 1,
+#             "steps": 10,
+#         },
+#     )
+    
+#     print(response.status_code)
+#     if response.status_code != 200:
+#         raise Exception("Non-200 response: " + str(response.text))
+    
+#     data = response.json()
+#     # base64_image = None
+#     for image in data["artifacts"]:
+#         with open(f"image_{num}.png", "wb") as f:
+#             f.write(base64.b64decode(image["base64"]))
+    
+#     # if base64_image is None:
+#     #     raise Exception("No image was generated.")
+    
+#     return f'image_{num}.png'
+
+# def generate_image_core(text, num):
+#   response = requests.post(
+#     f"https://api.stability.ai/v2beta/stable-image/generate/core",
+#     headers={
+#         "authorization": f"sk-6iUj0Jg2eeKDOpRJuDmCDSvPJdUJ6oP6qrQY3sujqR8h4ycF",
+#         "accept": "image/*"
+#     },
+#     files={"none": ''},
+#     data={
+#         "prompt": text,
+#         "output_format": "png",
+#         'aspect_ratio': "3:2"
+#     },
+#   )
+
+#   print(response.status_code)
+#   if response.status_code == 200:
+#       with open(f"image_{num}.png", 'wb') as file:
+#           file.write(response.content)
+#   else:
+#       raise Exception(str(response.json()))
+#   return f'image_{num}.png'
+
+# def generate_image_openai(text, num):
+
+#     client = OpenAI(api_key='sk-proj-TVCjX5VGWF5s18k0Z1G1T3BlbkFJZYp0HIC4NnxzqC0ne4YG')
+
+#     try:
+#         print(2)
+#         response = client.images.generate(
+#             model="dall-e-2",
+#             prompt=text,
+#             size="512x512",
+#             quality="standard",
+#             n=1
+#         )
+#         print(3)
+#         image_url = response.data[0].url
+#         print(4)
+#         print(f'image {num} generated')
+
+#         image_response = requests.get(image_url)
+#         print(5)
+#         if image_response.status_code == 200:
+#             with open(os.path.join(f'image_{num}.png'), 'wb') as file:
+#                 print(6)
+#                 file.write(image_response.content)
+#                 print(7)
+#         else:
+#             raise Exception(f"Failed to download image with status code {image_response.status_code} and message: {image_response.text}")
+
+#     except Exception as e:
+#         raise Exception(f"Image generation failed: {e}")
+
+#     return f'image_{num}.png'
+
+# @tool
+# def generate_images_and_add_to_blog(blog_content):
+#     """This tool is used to generate images and add them to blog
+#     Args:
+#     blog_content: A complete blog with prompts enclosed in <image> prompt </image> tag.
+#     Returns:
+#     A complete blog"""
+#     print('hi')
+#     image_descriptions = re.findall(r'<image>(.*?)</image>', blog_content)
+    
+#     for i, text in enumerate(image_descriptions):
+
+#         try:
+#             print(1)
+#             img_path = generate_image_openai(text, i)
+#             print(8)
+#             # image_tag = f'data:image/png;base64,{base64_img}'
+#             blog_content = blog_content.replace(f'<image>{text}</image>', f'![]({img_path})')
+#             print(9)
+#         except Exception as e:
+#             print(e)
+#             raise Exception(f"Image generation failed: {e}")
+
+#     with open('blog_post.md', 'w') as f:
+#         f.write(blog_content)
+    
+#     convert_md_to_docx('blog_post.md', 'blog_post.docx')
+        
+#     return blog_content
+
+def generate_image_openai(text, num):
+
+    temp_output_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
+    output_image = temp_output_file.name
+
+    client = OpenAI()
+
+    try:
+        response = client.images.generate(
+            model="dall-e-2",
+            prompt=text,
+            size="512x512",
+            quality="standard",
+            n=1
+        )
+        image_url = response.data[0].url
+
+        print(f'image {num} generated')
+
+        image_response = requests.get(image_url)
+        print('response')
+        if image_response.status_code == 200:
+            with open(output_image, 'wb') as file:
+                file.write(image_response.content)
+                print('write')
+        else:
+            raise Exception(f"Failed to download image with status code {image_response.status_code} and message: {image_response.text}")
+
+    except Exception as e:
+        raise Exception(f"Image generation failed: {e}")
+
+    return output_image
+
+@tool
+def generate_images_and_add_to_blog(blog_content):
+    """This tool is used to generate images and add them to blog
+    Args:
+    blog_content: A complete blog with prompts enclosed in <image> prompt </image> tag.
+    Returns:
+    A complete blog"""
+    print(blog_content)
+    print('*****************************************************')
+    print(type(blog_content))
+
+    blog_content = str(blog_content)
+    
+    image_descriptions = re.findall(r'<image>(.*?)</image>', blog_content)
+    
+    for i, text in enumerate(image_descriptions):
+
+        try:
+            temp_folder = tempfile.mkdtemp()
+            img_path = generate_image_openai(text, i)
+            # image_tag = f'data:image/png;base64,{base64_img}'
+            print(img_path)
+            blog_content = blog_content.replace(f'<image>{text}</image>', f'![]({img_path})')
+            print('blog content')
+        except Exception as e:
+            print(e)
+            raise Exception(f"Image generation failed: {e}")
+
+    try:
+        
+        print('blog')
+        with open('blog_post.md', 'w') as f:
+            f.write(blog_content)
+    
+        print('convert')
+        
+        convert_md_to_docx('blog_post.md', 'blog_post.docx')
+
+        print('converted')
+
+    except error:
+        print(error)
+        
+    return blog_content
+
+def process_script(script):
+    """Used to process the script into dictionary format"""
+    dict = {}
+    text_for_image_generation = re.findall(r'<image>(.*?)</?image>', script, re.DOTALL)
+    text_for_speech_generation = re.findall(r'<narration>(.*?)</?narration>', script, re.DOTALL)
+    dict['text_for_image_generation'] = text_for_image_generation
+    dict['text_for_speech_generation'] = text_for_speech_generation
+    return dict
+
+def generate_speech(text, lang='en', speed=1.0, num=0):
+    """
+    Generates speech for the given script using gTTS and adjusts the speed.
+    """
+    temp_speech_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp3')
+    temp_speech_path = temp_speech_file.name
+
+    
+    client = OpenAI()
+
+    speech_file_path = temp_speech_path
+    response = client.audio.speech.create(
+    model="tts-1",
+    voice="echo",
+    input= text
+    )
+
+    response.stream_to_file(speech_file_path)
+
+    # tts = gTTS(text=text, lang=lang)
+    # tts.save(temp_speech_path)
+
+    sound = AudioSegment.from_file(temp_speech_path)
+    if speed != 1.0:
+        sound_with_altered_speed = sound._spawn(sound.raw_data, overrides={
+            "frame_rate": int(sound.frame_rate * speed)
+        }).set_frame_rate(sound.frame_rate)
+        sound_with_altered_speed.export(temp_speech_path, format="mp3")
+    else:
+        sound.export(temp_speech_path, format="mp3")
+
+    temp_speech_file.close()
+    return temp_speech_path
+
+# def image_generator(script):
+#     """Generates images for the given script.
+#     Saves it to a temporary directory and returns the path.
+#     Args:
+#     script: a complete script containing narrations and image descriptions."""
+
+#     # remove_temp_files('/tmp')
+
+#     images_dir = tempfile.mkdtemp()
+
+#     dict = process_script(script)
+#     for i, text in enumerate(dict['text_for_image_generation']):
+#             try:
+#                 # core
+#                 # response = requests.post(
+#                 # f"https://api.stability.ai/v2beta/stable-image/generate/core",
+#                 # headers={
+#                 #     "authorization": f"sk-5VTo97D19Ruf2zLinj3pQbVXmLmh2Ps354PGkufTHtqmB2BN",
+#                 #     "accept": "image/*"
+#                 # },
+#                 # files={"none": ''},
+#                 # data={
+#                 #     "prompt": text,
+#                 #     "output_format": "png",
+#                 #     'aspect_ratio': "9:16"
+#                 # },
+#                 # )
+
+#                 # print(response.status_code)
+#                 # if response.status_code == 200:
+#                 #     with open(os.path.join(images_dir, f'image_{i}.png'), 'wb') as file:
+#                 #         file.write(response.content)
+#                 # else:
+#                 #     raise Exception(str(response.json()))
+            
+#                 # v1
+#                 # engine_id = "stable-diffusion-v1-6"
+#                 # api_host = os.getenv('API_HOST', 'https://api.stability.ai')
+#                 # api_key = 'sk-Z3EF1ebJ9oJUht6Q9fsh861wOsNhRFkxYXMYHNl7gt7xpBMD'
+#                 # if api_key is None:
+#                 #     raise Exception("Missing Stability API key.")
+
+#                 # response = requests.post(
+#                 #     f"{api_host}/v1/generation/{engine_id}/text-to-image",
+#                 #     headers={
+#                 #         "Content-Type": "application/json",
+#                 #         "Accept": "application/json",
+#                 #         "Authorization": f"Bearer {api_key}"
+#                 #     },
+#                 #     json={
+#                 #         "text_prompts": [
+#                 #             {
+#                 #                 "text": text
+#                 #             }
+#                 #         ],
+#                 #         "cfg_scale": 7,
+#                 #         "height": 512,
+#                 #         "width": 512,
+#                 #         "samples": 1,
+#                 #         "steps": 10,
+#                 #     },
+#                 # )
+
+#                 # print(response.status_code)
+#                 # if response.status_code != 200:
+#                 #     raise Exception("Non-200 response: " + str(response.text))
+
+#                 # data = response.json()
+#                 # # base64_image = None
+#                 # for image in data["artifacts"]:
+#                 #     with open(os.path.join(images_dir, f'image_{i}.png'), "wb") as f:
+#                 #         f.write(base64.b64decode(image["base64"]))
+
+#                 pass
+
+#             except Exception as e:
+#                 print(e)
+#                 raise Exception(f"Image generation failed: {e}")
+
+#     return images_dir
+
+def image_generator(script):
+    """Generates images for the given script.
+    Saves it to a temporary directory and returns the path.
+    Args:
+    script: a complete script containing narrations and image descriptions."""
+
+    # remove_temp_files('/tmp')
+    
+    images_dir = tempfile.mkdtemp()
+
+    client = OpenAI()
+    dict = process_script(script)
+    for i, text in enumerate(dict['text_for_image_generation']):
+        try:
+            response = client.images.generate(
+                model="dall-e-2",
+                prompt=text,
+                size="512x512",
+                quality="standard",
+                n=1
+            )
+            image_url = response.data[0].url
+
+            print(f'image {i} generated')
+            # Download the image
+            image_response = requests.get(image_url)
+            if image_response.status_code == 200:
+                with open(os.path.join(images_dir, f'image_{i}.png'), 'wb') as file:
+                    file.write(image_response.content)
+            else:
+                raise Exception(f"Failed to download image with status code {image_response.status_code} and message: {image_response.text}")
+
+        except Exception as e:
+            raise Exception(f"Image generation failed: {e}")
+
+    return images_dir
+
+def speech_generator(script):
+    """
+    Generates speech files for the given script using gTTS.
+    Saves them to a temporary directory and returns the path.
+    Args:
+    script: a complete script containing narrations and image descriptions.
+    """
+    speeches_dir = tempfile.mkdtemp()
+
+    dict = process_script(script)
+    for i, text in enumerate(dict['text_for_speech_generation']):
+        speech_path = generate_speech(text, num=i)
+        print(f'speech {i} generated')
+        os.rename(speech_path, os.path.join(speeches_dir, f'speech_{i}.mp3'))
+
+    return speeches_dir, dict['text_for_speech_generation']
+
+def split_text_into_chunks(text, chunk_size):
+    words = text.split()
+    return [' '.join(words[i:i + chunk_size]) for i in range(0, len(words), chunk_size)]
+
+def add_text_to_video(input_video, text, duration=1, fontsize=40, fontcolor=(255, 255, 255),
+                      outline_thickness=2, outline_color=(0, 0, 0), delay_between_chunks=0.3,
+                      font_path='Montserrat-Bold.ttf'):
+    temp_output_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
+    output_video = temp_output_file.name
+
+    chunks = split_text_into_chunks(text, 3)  # Adjust chunk size as needed
+
+    cap = cv2.VideoCapture(input_video)
+    if not cap.isOpened():
+        raise ValueError("Error opening video file.")
+
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    out = cv2.VideoWriter(output_video, fourcc, fps, (width, height))
+
+    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    chunk_duration_frames = duration * fps
+    delay_frames = int(delay_between_chunks * fps)
+
+    if not os.path.exists(font_path):
+        raise FileNotFoundError(f"Font file not found: {font_path}")
+
+    try:
+        font = ImageFont.truetype(font_path, fontsize)
+    except Exception as e:
+        raise RuntimeError(f"Error loading font: {e}")
+
+    current_frame = 0
+
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        frame_pil = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+        draw = ImageDraw.Draw(frame_pil)
+
+        chunk_index = current_frame // (chunk_duration_frames + delay_frames)
+
+        if current_frame % (chunk_duration_frames + delay_frames) < chunk_duration_frames and chunk_index < len(chunks):
+            chunk = chunks[chunk_index]
+            text_bbox = draw.textbbox((0, 0), chunk, font=font)
+            text_width, text_height = text_bbox[2] - text_bbox[0], text_bbox[3] - text_bbox[1]
+            text_x = (width - text_width) // 2
+            text_y = height - 100  # Position text at the bottom
+
+            if text_width > width:
+                words = chunk.split()
+                half = len(words) // 2
+                line1 = ' '.join(words[:half])
+                line2 = ' '.join(words[half:])
+
+                text_size_line1 = draw.textsize(line1, font=font)
+                text_size_line2 = draw.textsize(line2, font=font)
+                text_x_line1 = (width - text_size_line1[0]) // 2
+                text_x_line2 = (width - text_size_line2[0]) // 2
+                text_y = height - 250 - text_size_line1[1]  # Adjust vertical position for two lines
+
+                for dx in range(-outline_thickness, outline_thickness + 1):
+                    for dy in range(-outline_thickness, outline_thickness + 1):
+                        if dx != 0 or dy != 0:
+                            draw.text((text_x_line1 + dx, text_y + dy), line1, font=font, fill=outline_color)
+                            draw.text((text_x_line2 + dx, text_y + text_size_line1[1] + dy), line2, font=font, fill=outline_color)
+                
+                draw.text((text_x_line1, text_y), line1, font=font, fill=fontcolor)
+                draw.text((text_x_line2, text_y + text_size_line1[1]), line2, font=font, fill=fontcolor)
+
+            else:
+                for dx in range(-outline_thickness, outline_thickness + 1):
+                    for dy in range(-outline_thickness, outline_thickness + 1):
+                        if dx != 0 or dy != 0:
+                            draw.text((text_x + dx, text_y + dy), chunk, font=font, fill=outline_color)
+                
+                draw.text((text_x, text_y), chunk, font=font, fill=fontcolor)
+
+            frame = cv2.cvtColor(np.array(frame_pil), cv2.COLOR_RGB2BGR)
+
+        out.write(frame)
+        current_frame += 1
+
+        # Ensure loop breaks after processing all frames
+        if current_frame >= frame_count:
+            break
+
+    cap.release()
+    out.release()
+    cv2.destroyAllWindows()
+    
+    return output_video
+
+def apply_zoom_in_effect(clip, zoom_factor=1.2):
+    width, height = clip.size
+    duration = clip.duration
+
+    def zoom_in_effect(get_frame, t):
+        frame = get_frame(t)
+        zoom = 1 + (zoom_factor - 1) * (t / duration)
+        new_width, new_height = int(width * zoom), int(height * zoom)
+        resized_frame = cv2.resize(frame, (new_width, new_height))
+        
+        x_start = (new_width - width) // 2
+        y_start = (new_height - height) // 2
+        cropped_frame = resized_frame[y_start:y_start + height, x_start:x_start + width]
+        
+        return cropped_frame
+
+    return clip.fl(zoom_in_effect, apply_to=['mask'])
+
+def create_video_from_images_and_audio(images_dir, speeches_dir, final_video_filename, all_captions):
+    """Creates video using images and audios.
+    Args:
+    images_dir: path to images folder
+    speeches_dir: path to speeches folder
+    final_video_filename: the topic name which will be used as final video file name"""
+    print('hi')
+    client = Groq(api_key='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')
+    # images_paths = sorted(os.listdir(images_dir))
+    # audio_paths = sorted(os.listdir(speeches_dir))
+    images_paths = sorted([os.path.join(images_dir, img) for img in os.listdir(images_dir) if img.endswith('.png') or img.endswith('.jpg')])
+    audio_paths = sorted([os.path.join(speeches_dir, speech) for speech in os.listdir(speeches_dir) if speech.endswith('.mp3')])
+    clips = []
+    temp_files = []
+    video_dir = tempfile.mkdtemp()
+    
+    for i in range(min(len(images_paths), len(audio_paths))):
+        img_clip = ImageClip(os.path.join(images_dir, images_paths[i]))
+        audioclip = AudioFileClip(os.path.join(speeches_dir, audio_paths[i]))
+        videoclip = img_clip.set_duration(audioclip.duration)
+        zoomed_clip = apply_zoom_in_effect(videoclip, 1.3)
+        
+        # with open(os.path.join(speeches_dir, audio_paths[i]), "rb") as file:
+        #     transcription = client.audio.transcriptions.create(
+        #         file=(audio_paths[i], file.read()),
+        #         model="whisper-large-v3",
+        #         response_format="verbose_json",
+        #     )
+        #     caption = transcription.text
+        temp_video_path = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4').name
+        zoomed_clip.write_videofile(temp_video_path, codec='libx264', fps=24)
+        temp_files.append(temp_video_path)
+        
+        caption = all_captions[i]
+        final_video_path = add_text_to_video(temp_video_path, caption, duration=1, fontsize=20)
+        temp_files.append(final_video_path)
+        
+        final_clip = VideoFileClip(final_video_path)
+        final_clip = final_clip.set_audio(audioclip)
+
+        print(f'create small video {i}')
+        clips.append(final_clip)
+    
+    final_clip = concatenate_videoclips(clips)
+    if not final_video_filename.endswith('.mp4'):
+        final_video_filename = final_video_filename + '.mp4'
+    final_clip.write_videofile(os.path.join(video_dir, final_video_filename), codec='libx264', fps=24)
+    
+    # Close all video files properly
+    for clip in clips:
+        clip.close()
+        
+    # Remove all temporary files
+    for temp_file in temp_files:
+        try:
+            os.remove(temp_file)
+        except Exception as e:
+            print(f"Error removing file {temp_file}: {e}")
+    
+    return os.path.join(video_dir, final_video_filename)
+
+@tool
+def generate_video(pairs, final_video_filename):
+    """ Generates video using narration and image prompt pairs.
+
+    Args:
+        pairs:A string of arration and image prompt pairs enclosed in <narration> and <image> tags.
+        final_video_filename: the topic name which will be used as final video file name
+
+    Returns:
+        Generated video path"""
+
+    images_dir = image_generator(pairs)
+    print(images_dir)
+    speeches_dir, all_captions = speech_generator(pairs)
+    print(speeches_dir)
+    video_path = create_video_from_images_and_audio(images_dir, speeches_dir, final_video_filename, all_captions)
+    print('video', video_path)
+
+    with open(video_path, 'rb') as f:
+        video = f.read()
+    with open('video.mp4', 'wb') as f:
+        f.write(video)
+
+    return video_path

trained_agents_data.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:926248e52d1fa532c317e37da24ed652ae64110f8219cb5e061668bd3091f048
+size 5

utils.py

@@ -0,0 +1,217 @@
+from email.mime.text import MIMEText
+from google.oauth2 import service_account
+from googleapiclient.http import MediaFileUpload
+import base64
+import os
+import base64
+import streamlit as st
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+from email.mime.multipart import MIMEMultipart
+import requests
+import json
+from langchain.tools import tool
+
+# Constants
+SCOPES_DRIVE = ['https://www.googleapis.com/auth/drive']
+SERVICE_ACCOUNT_FILE = 'service_account.json'
+PARENT_FOLDER_ID = "1REXfwxk9dcPdpZXJOFZSur3880soVN9y"
+
+
+# Authenticate and return credentials for Google Drive
+def authenticate_drive():
+    credentials = service_account.Credentials.from_service_account_file(
+        SERVICE_ACCOUNT_FILE, scopes=SCOPES_DRIVE)
+    return credentials
+
+# Upload file to Google Drive
+def upload_file(filepath, filename, parent_folder_id):
+    creds = authenticate_drive()
+    service = build('drive', 'v3', credentials=creds)
+
+    file_metadata = {
+        'name': filename,
+        'parents': [parent_folder_id]
+    }
+
+    media = MediaFileUpload(filepath, resumable=True)
+    file = service.files().create(body=file_metadata, media_body=media, fields='id').execute()
+    print(f'File ID: {file.get("id")}')
+    return file.get('id')
+
+SCOPES = ["https://www.googleapis.com/auth/gmail.send"]
+
+def authenticate_gmail():
+    """Authenticate and return the Gmail service."""
+    creds = None
+    if os.path.exists("token.json"):
+        creds = Credentials.from_authorized_user_file("token.json", SCOPES)
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+            creds.refresh(Request())
+        else:
+            flow = InstalledAppFlow.from_client_secrets_file("credentials.json", SCOPES)
+            creds = flow.run_local_server(port=0)
+        with open("token.json", "w") as token:
+            token.write(creds.to_json())
+    service = build("gmail", "v1", credentials=creds)
+    return service
+
+def send_email_with_company_details(user_email, company_name, topic):
+
+
+    blog_id = upload_file('blog_post.docx', 'blog post', PARENT_FOLDER_ID)
+    video_id = upload_file('video.mp4', 'video', PARENT_FOLDER_ID)
+
+    # Prepare email content
+    blog_link = f"https://drive.google.com/file/d/{blog_id}/view?usp=sharing"
+    video_link = f"https://drive.google.com/file/d/{video_id}/view?usp=sharing"
+    email_subject = f"Blog and Video for the topic {topic}"
+    email_body = f"""
+    <html>
+        <body>
+            <p>Hello,</p>
+            <p>The requested blog and video has been shared with you by <b>{company_name}</b>.</p>
+            <p>You can view the files using the following links:</p>
+            <b>Blog:</b>
+            <a href="{blog_link}"> {topic}</a>
+            <br>
+            <br>
+            <b>Video:</b>
+            <a href="{video_link}"> {topic}</a>
+            <br>
+            <p>Best regards,<br>{company_name}</p>
+        </body>
+    </html>
+    """
+
+    try:
+        # Create message container - the correct MIME type is multipart/alternative.
+        msg = MIMEMultipart('alternative')
+        msg['to'] = user_email
+        msg['subject'] = email_subject
+
+        # Attach parts into message container
+        part1 = MIMEText(email_body, 'plain')
+        part2 = MIMEText(email_body, 'html')
+        msg.attach(part1)
+        msg.attach(part2)
+
+        raw_string = base64.urlsafe_b64encode(msg.as_bytes()).decode()
+
+        service = authenticate_gmail()
+        sent_message = service.users().messages().send(userId='me', body={'raw': raw_string}).execute()
+
+        # # Connect to the SMTP server
+        # server = smtplib.SMTP('smtp.gmail.com', 587)
+        # server.starttls()  # Secure the connection
+        # server.login(SENDER_EMAIL, PASSWORD)
+        # server.sendmail(SENDER_EMAIL, user_email, msg.as_string())
+        print('Email sent successfully!')
+    except Exception as e:
+        print(f'Error sending email: {str(e)}')
+
+# Upload blog post and video, then share them and send an email
+# def main():
+#     blog_filepath = 'blog_post.docx'
+#     video_filepath = 'video.mp4'
+#     user_email = receiver_email
+#     company_name = 'digiotai'
+
+#     # Upload blog post
+#     blog_file_id = upload_file(blog_filepath, 'blog post', PARENT_FOLDER_ID)
+#     # Upload video
+#     video_file_id = upload_file(video_filepath, 'video', PARENT_FOLDER_ID)
+
+#     send_email_with_company_details(blog_file_id, video_file_id, user_email, company_name)
+
+# main()
+
+
+def get_urn(token):
+    # access_token = '<your_access_token>'
+    url = 'https://api.linkedin.com/v2/userinfo'
+
+    headers = {
+        'Authorization': f'Bearer {token}'
+    }
+
+    response = requests.get(url, headers=headers)
+
+    if response.status_code == 200:
+        user_info = response.json()
+        print(user_info['sub'])
+        return user_info['sub']
+    else:
+        print(f'Failed to fetch user info: {response.status_code}')
+        print(response.text)
+
+@tool
+def post_image_and_text(
+    token: str, title: str, image_path: str, text_content: str
+):
+    """
+    Posts an article on LinkedIn with an image.
+
+    :param token: str. LinkedIn OAuth token.
+    :param title: str. Article title.
+    :param text_content: str. Article content.
+    :param image_path: str. Local file path of the image to be used as a thumbnail.
+    """
+
+    owner = get_urn(token)
+
+    # Initialize the upload to get the upload URL and image URN
+    init_url = "https://api.linkedin.com/rest/images?action=initializeUpload"
+    headers = {
+        "LinkedIn-Version": "202401",
+        "X-RestLi-Protocol-Version": "2.0.0",
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {token}",
+    }
+    init_data = json.dumps({"initializeUploadRequest": {"owner": f'urn:li:person:{owner}'}})
+    init_response = requests.post(init_url, headers=headers, data=init_data)
+    print(init_response.content)
+    if init_response.status_code != 200:
+        raise Exception(f"Failed to initialize upload: {init_response.text}")
+
+    init_response_data = init_response.json()["value"]
+    upload_url = init_response_data["uploadUrl"]
+    image_urn = init_response_data["image"]
+
+    # Upload the file
+    with open(image_path, "rb") as f:
+        upload_response = requests.post(upload_url, files={"file": f})
+        if upload_response.status_code not in [200, 201]:
+            raise Exception(f"Failed to upload file: {upload_response.text}")
+
+    # Create the post with the uploaded image URN as thumbnail
+    post_url = "https://api.linkedin.com/rest/posts"
+    post_data = json.dumps(
+        {
+            "author": f'urn:li:person:{owner}',
+            "commentary": text_content,
+            "visibility": "PUBLIC",
+            "distribution": {
+                "feedDistribution": "MAIN_FEED",
+                "targetEntities": [],
+                "thirdPartyDistributionChannels": [],
+            },
+            "content": {
+                "media": {
+                    "title": title,
+                    "id": image_urn,
+                }
+            },
+            "lifecycleState": "PUBLISHED",
+            "isReshareDisabledByAuthor": False,
+        }
+    )
+    post_response = requests.post(post_url, headers=headers, data=post_data)
+    print(post_response.content)
+    if post_response.status_code in [200, 201]:
+        return "Linkedin article has been posted successfully!"
+    else:
+        raise Exception(f"Failed to post article: {post_response.text}")    

video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e72d993994dccaa7ae8c0236059aa2d457a8ce79f31a42b98adaa19de8d05ada
+size 2672279