Automated Email Responder

 import imaplib

import smtplib

import email

from email.mime.text import MIMEText

import openai

# Gmail Credentials

EMAIL_USER = "your_email@gmail.com"

EMAIL_PASS = "your_app_password"

# OpenAI API Key (Optional)

OPENAI_API_KEY = "your_openai_api_key"

openai.api_key = OPENAI_API_KEY

# Connect to Gmail Inbox

def check_inbox():

    mail = imaplib.IMAP4_SSL("imap.gmail.com")

    mail.login(EMAIL_USER, EMAIL_PASS)

    mail.select("inbox")

    _, messages = mail.search(None, "UNSEEN")

    email_ids = messages[0].split()

    for email_id in email_ids:

        _, msg_data = mail.fetch(email_id, "(RFC822)")

        for response_part in msg_data:

            if isinstance(response_part, tuple):

                msg = email.message_from_bytes(response_part[1])

                sender = msg["From"]

                subject = msg["Subject"]

                body = extract_body(msg)

                print(f"New Email from: {sender}")

                print(f"Subject: {subject}")

                print(f"Body: {body}")

                reply_message = generate_reply(body)

                send_email(sender, reply_message)

    mail.logout()

# Extract Email Body

def extract_body(msg):

    if msg.is_multipart():

        for part in msg.walk():

            if part.get_content_type() == "text/plain":

                return part.get_payload(decode=True).decode()

    return msg.get_payload(decode=True).decode()

# Generate AI-Based Response (Optional)

def generate_reply(user_query):

    prompt = f"Reply professionally to this email: {user_query}"

    response = openai.ChatCompletion.create(

        model="gpt-3.5-turbo",

        messages=[{"role": "system", "content": "You are a professional email assistant."},

                  {"role": "user", "content": prompt}]

    )

    return response["choices"][0]["message"]["content"]

# Send Email Response

def send_email(to_email, message):

    smtp_server = smtplib.SMTP_SSL("smtp.gmail.com", 465)

    smtp_server.login(EMAIL_USER, EMAIL_PASS)

    msg = MIMEText(message)

    msg["Subject"] = "Re: Your Inquiry"

    msg["From"] = EMAIL_USER

    msg["To"] = to_email

    smtp_server.sendmail(EMAIL_USER, to_email, msg.as_string())

    smtp_server.quit()

    print(f"Auto-reply sent to {to_email}")

# Run the Email Bot

if __name__ == "__main__":

    check_inbox()

YouTube Video Summarizer

 pip install youtube-transcript-api nltk sumy

import tkinter as tk

from tkinter import messagebox

from youtube_transcript_api import YouTubeTranscriptApi

from sumy.parsers.plaintext import PlaintextParser

from sumy.nlp.tokenizers import Tokenizer

from sumy.summarizers.lsa import LsaSummarizer

# Function to extract video ID from URL

def extract_video_id(url):

    if "youtube.com/watch?v=" in url:

        return url.split("v=")[1].split("&")[0]

    elif "youtu.be/" in url:

        return url.split("youtu.be/")[1].split("?")[0]

    else:

        return None

# Function to fetch transcript

def get_transcript(video_url):

    video_id = extract_video_id(video_url)

    if not video_id:

        messagebox.showerror("Error", "Invalid YouTube URL")

        return None

    try:

        transcript = YouTubeTranscriptApi.get_transcript(video_id)

        full_text = " ".join([entry["text"] for entry in transcript])

        return full_text

    except Exception as e:

        messagebox.showerror("Error", f"Could not fetch transcript: {str(e)}")

        return None

# Function to summarize text

def summarize_text(text, num_sentences=3):

    parser = PlaintextParser.from_string(text, Tokenizer("english"))

    summarizer = LsaSummarizer()

    summary = summarizer(parser.document, num_sentences)

    return " ".join(str(sentence) for sentence in summary)

# Function to fetch and summarize

def summarize_video():

    video_url = url_entry.get()

    transcript = get_transcript(video_url)

    

    if transcript:

        summary = summarize_text(transcript)

        output_text.delete("1.0", tk.END)

        output_text.insert(tk.END, summary)

# GUI

root = tk.Tk()

root.title("YouTube Video Summarizer")

tk.Label(root, text="Enter YouTube Video URL:").pack()

url_entry = tk.Entry(root, width=50)

url_entry.pack()

tk.Button(root, text="Summarize", command=summarize_video).pack()

output_text = tk.Text(root, height=10, width=60)

output_text.pack()

root.mainloop()

Automated Screenshot Tool

 pip install pyautogui

import pyautogui

import time

import os

import tkinter as tk

from tkinter import messagebox

# Folder to save screenshots

screenshot_folder = "screenshots"

if not os.path.exists(screenshot_folder):

    os.makedirs(screenshot_folder)

# Function to take a screenshot

def take_screenshot():

    timestamp = time.strftime("%Y-%m-%d_%H-%M-%S")

    filename = os.path.join(screenshot_folder, f"screenshot_{timestamp}.png")

    screenshot = pyautogui.screenshot()

    screenshot.save(filename)

    print(f"✅ Screenshot saved: {filename}")

# Function to start auto screenshots

def start_screenshot():

    try:

        interval = int(entry.get())

        messagebox.showinfo("Started", f"Taking screenshots every {interval} seconds.")

        

        while True:

            take_screenshot()

            time.sleep(interval)

    except ValueError:

        messagebox.showerror("Error", "Please enter a valid number.")

# GUI with Tkinter

root = tk.Tk()

root.title("Automated Screenshot Tool")

tk.Label(root, text="Enter Screenshot Interval (seconds):").pack()

entry = tk.Entry(root)

entry.pack()

tk.Button(root, text="Start Screenshot Capture", command=start_screenshot).pack()

tk.Button(root, text="Exit", command=root.quit).pack()

root.mainloop()

Invoice Generator

 pip install reportlab

from reportlab.lib.pagesizes import letter

from reportlab.pdfgen import canvas

def generate_invoice(client_name, items, tax_rate=0.05, filename="invoice.pdf"):

    c = canvas.Canvas(filename, pagesize=letter)

    width, height = letter

    # Title

    c.setFont("Helvetica-Bold", 16)

    c.drawString(50, height - 50, "INVOICE")

    # Client Details

    c.setFont("Helvetica", 12)

    c.drawString(50, height - 80, f"Client: {client_name}")

    # Table Headers

    c.setFont("Helvetica-Bold", 12)

    c.drawString(50, height - 120, "Item")

    c.drawString(250, height - 120, "Quantity")

    c.drawString(350, height - 120, "Price")

    c.drawString(450, height - 120, "Total")

    # Invoice Items

    c.setFont("Helvetica", 12)

    y_position = height - 140

    total_cost = 0

    for item, details in items.items():

        quantity, price = details

        total = quantity * price

        total_cost += total

        c.drawString(50, y_position, item)

        c.drawString(250, y_position, str(quantity))

        c.drawString(350, y_position, f"${price:.2f}")

        c.drawString(450, y_position, f"${total:.2f}")

        y_position -= 20

    # Tax and Total Calculation

    tax_amount = total_cost * tax_rate

    grand_total = total_cost + tax_amount

    c.setFont("Helvetica-Bold", 12)

    c.drawString(350, y_position - 20, "Subtotal:")

    c.drawString(450, y_position - 20, f"${total_cost:.2f}")

    c.drawString(350, y_position - 40, f"Tax ({tax_rate * 100}%):")

    c.drawString(450, y_position - 40, f"${tax_amount:.2f}")

    c.drawString(350, y_position - 60, "Grand Total:")

    c.drawString(450, y_position - 60, f"${grand_total:.2f}")

    # Save PDF

    c.save()

    print(f"✅ Invoice saved as {filename}")

PDF to Audio Converter

 pip install PyMuPDF gtts tk

import fitz  # PyMuPDF

from gtts import gTTS

import tkinter as tk

from tkinter import filedialog, messagebox

import os

# Function to extract text from PDF

def extract_text_from_pdf(pdf_path):

    doc = fitz.open(pdf_path)

    text = ""

    for page in doc:

        text += page.get_text("text") + "\n"

    return text

# Function to convert text to speech

def convert_text_to_audio(text, output_file):

    if text.strip():

        tts = gTTS(text=text, lang='en')

        tts.save(output_file)

        messagebox.showinfo("Success", f"Audio file saved as {output_file}")

        os.system(f"start {output_file}")  # Opens the audio file

    else:

        messagebox.showwarning("Warning", "No text found in PDF.")

# Function to open file dialog

def select_pdf():

    file_path = filedialog.askopenfilename(filetypes=[("PDF Files", "*.pdf")])

    if file_path:

        text = extract_text_from_pdf(file_path)

        if text:

            convert_text_to_audio(text, "output_audio.mp3")

# Tkinter GUI Setup

root = tk.Tk()

root.title("PDF to Audio Converter 🔊")

root.geometry("400x200")

lbl_title = tk.Label(root, text="📄 PDF to Audio Converter 🔊", font=("Arial", 14, "bold"))

lbl_title.pack(pady=10)

btn_select_pdf = tk.Button(root, text="Select PDF & Convert", command=select_pdf, font=("Arial", 12))

btn_select_pdf.pack(pady=20)

root.mainloop()