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()

Network Speed Monitor

 pip install speedtest-cli matplotlib tk

import speedtest

import tkinter as tk

from tkinter import ttk

import threading

import matplotlib.pyplot as plt

from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg

# Function to test internet speed

def test_speed():

    st = speedtest.Speedtest()

    st.get_best_server()

    

    download_speed = round(st.download() / 1_000_000, 2)  # Convert to Mbps

    upload_speed = round(st.upload() / 1_000_000, 2)  # Convert to Mbps

    return download_speed, upload_speed

# Function to update the speed in GUI

def update_speed():

    global speeds_download, speeds_upload

    

    while True:

        download, upload = test_speed()

        speeds_download.append(download)

        speeds_upload.append(upload)

        lbl_download.config(text=f"Download Speed: {download} Mbps")

        lbl_upload.config(text=f"Upload Speed: {upload} Mbps")

        update_graph()

        root.update_idletasks()

# Function to update the speed graph

def update_graph():

    ax.clear()

    ax.plot(speeds_download, label="Download Speed (Mbps)", color="blue")

    ax.plot(speeds_upload, label="Upload Speed (Mbps)", color="red")

    

    ax.set_title("Network Speed Over Time")

    ax.set_xlabel("Test Count")

    ax.set_ylabel("Speed (Mbps)")

    ax.legend()

    ax.grid()

    canvas.draw()

# Tkinter GUI setup

root = tk.Tk()

root.title("Network Speed Monitor 🌐")

root.geometry("500x500")

lbl_title = tk.Label(root, text="📡 Network Speed Monitor", font=("Arial", 14, "bold"))

lbl_title.pack(pady=10)

lbl_download = tk.Label(root, text="Download Speed: -- Mbps", font=("Arial", 12))

lbl_download.pack(pady=5)

lbl_upload = tk.Label(root, text="Upload Speed: -- Mbps", font=("Arial", 12))

lbl_upload.pack(pady=5)

# Matplotlib graph setup

fig, ax = plt.subplots(figsize=(5, 3))

speeds_download = []

speeds_upload = []

canvas = FigureCanvasTkAgg(fig, master=root)

canvas.get_tk_widget().pack()

# Run speed test in a separate thread

threading.Thread(target=update_speed, daemon=True).start()

root.mainloop()

Code Syntax Highlighter

 pip install pygments

from pygments import highlight

from pygments.lexers import guess_lexer, PythonLexer, JavascriptLexer, CLexer

from pygments.formatters import TerminalFormatter, HtmlFormatter

# Function to highlight code in terminal

def highlight_code_terminal(code, language="python"):

    # Choose lexer based on language

    lexer = {

        "python": PythonLexer(),

        "javascript": JavascriptLexer(),

        "c": CLexer(),

    }.get(language.lower(), guess_lexer(code))

    highlighted_code = highlight(code, lexer, TerminalFormatter())

    return highlighted_code

# Function to highlight code and save as HTML

def highlight_code_html(code, language="python", output_file="highlighted_code.html"):

    lexer = {

        "python": PythonLexer(),

        "javascript": JavascriptLexer(),

        "c": CLexer(),

    }.get(language.lower(), guess_lexer(code))

    formatter = HtmlFormatter(full=True, style="monokai")

    highlighted_code = highlight(code, lexer, formatter)

    # Save to an HTML file

    with open(output_file, "w", encoding="utf-8") as f:

        f.write(highlighted_code)

    

    print(f"✅ Highlighted code saved to {output_file}")

from pygments import highlight

from pygments.lexers import guess_lexer, PythonLexer, JavascriptLexer, CLexer

from pygments.formatters import TerminalFormatter, HtmlFormatter

# Function to highlight code in terminal

def highlight_code_terminal(code, language="python"):

    # Choose lexer based on language

    lexer = {

        "python": PythonLexer(),

        "javascript": JavascriptLexer(),

        "c": CLexer(),

    }.get(language.lower(), guess_lexer(code))

    highlighted_code = highlight(code, lexer, TerminalFormatter())

    return highlighted_code

# Function to highlight code and save as HTML

def highlight_code_html(code, language="python", output_file="highlighted_code.html"):

    lexer = {

        "python": PythonLexer(),

        "javascript": JavascriptLexer(),

        "c": CLexer(),

    }.get(language.lower(), guess_lexer(code))

    formatter = HtmlFormatter(full=True, style="monokai")

    highlighted_code = highlight(code, lexer, formatter)

    # Save to an HTML file

    with open(output_file, "w", encoding="utf-8") as f:

        f.write(highlighted_code)

    

    print(f"✅ Highlighted code saved to {output_file}")

# Example usage

if __name__ == "__main__":

    code_sample = """

    def greet(name):

        print(f"Hello, {name}!")

    

    greet("abc")

    """

    print("🎨 Terminal Highlighted Code:")

    print(highlight_code_terminal(code_sample, "python"))

    highlight_code_html(code_sample, "python")