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

Resume Parser & Analyzer

pip install spacy pdfminer.six python-docx pandas nltk

python -m spacy download en_core_web_sm

import re

import spacy

import pdfminer.high_level

import docx

import nltk

from collections import Counter

nltk.download("stopwords")

from nltk.corpus import stopwords

# Load spaCy NLP model

nlp = spacy.load("en_core_web_sm")

# Function to extract text from PDF

def extract_text_from_pdf(pdf_path):

    return pdfminer.high_level.extract_text(pdf_path)

# Function to extract text from DOCX

def extract_text_from_docx(docx_path):

    doc = docx.Document(docx_path)

    return "\n".join([para.text for para in doc.paragraphs])

# Function to extract email from text

def extract_email(text):

    email_pattern = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"

    emails = re.findall(email_pattern, text)

    return emails[0] if emails else None

# Function to extract phone number from text

def extract_phone(text):

    phone_pattern = r"\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}"

    phones = re.findall(phone_pattern, text)

    return phones[0] if phones else None

# Function to extract skills from text

def extract_skills(text):

    skills_list = ["Python", "Java", "C++", "Machine Learning", "Data Science", "SQL", "Django", "React", "Flask"]

    found_skills = [skill for skill in skills_list if skill.lower() in text.lower()]

    return found_skills

# Function to extract name using NLP

def extract_name(text):

    doc = nlp(text)

    for ent in doc.ents:

        if ent.label_ == "PERSON":

            return ent.text

    return None

# Function to match skills with a job description

def match_skills(resume_skills, job_description):

    job_tokens = nltk.word_tokenize(job_description.lower())

    stop_words = set(stopwords.words("english"))

    filtered_job_tokens = [word for word in job_tokens if word not in stop_words]

    skill_match_count = sum(1 for skill in resume_skills if skill.lower() in filtered_job_tokens)

    match_percentage = (skill_match_count / len(resume_skills)) * 100 if resume_skills else 0

    return round(match_percentage, 2)

# Main function

def analyze_resume(file_path, job_description):

    # Extract text

    text = extract_text_from_pdf(file_path) if file_path.endswith(".pdf") else extract_text_from_docx(file_path)

    # Extract details

    name = extract_name(text)

    email = extract_email(text)

    phone = extract_phone(text)

    skills = extract_skills(text)

    match_percentage = match_skills(skills, job_description)

    # Display results

    print("\n📄 Resume Analysis Results:")

    print(f"👤 Name: {name}")

    print(f"📧 Email: {email}")

    print(f"📞 Phone: {phone}")

    print(f"🛠 Skills: {', '.join(skills)}")

    print(f"✅ Skill Match with Job: {match_percentage}%")

    return {"name": name, "email": email, "phone": phone, "skills": skills, "match_percentage": match_percentage}

Automated File Organizer

 import os

import shutil

# Define file categories with their extensions

FILE_CATEGORIES = {

    "Images": [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg"],

    "Documents": [".pdf", ".docx", ".txt", ".xlsx", ".pptx", ".csv"],

    "Videos": [".mp4", ".avi", ".mkv", ".mov"],

    "Music": [".mp3", ".wav", ".flac"],

    "Archives": [".zip", ".rar", ".tar", ".gz"],

    "Programs": [".exe", ".msi", ".dmg"],

    "Others": []

}

def organize_files(folder_path):

    """Organizes files into categorized folders based on extensions."""

    

    if not os.path.exists(folder_path):

        print(f"Error: The folder '{folder_path}' does not exist.")

        return

    

    # Create folders if they don't exist

    for category in FILE_CATEGORIES.keys():

        category_path = os.path.join(folder_path, category)

        os.makedirs(category_path, exist_ok=True)

    # Iterate through all files in the folder

    for file_name in os.listdir(folder_path):

        file_path = os.path.join(folder_path, file_name)

        

        # Skip directories

        if os.path.isdir(file_path):

            continue

        

        # Get file extension

        file_ext = os.path.splitext(file_name)[1].lower()

        # Determine the correct category for the file

        destination_folder = "Others"  # Default category

        for category, extensions in FILE_CATEGORIES.items():

            if file_ext in extensions:

                destination_folder = category

                break

        # Move the file to the correct folder

        shutil.move(file_path, os.path.join(folder_path, destination_folder, file_name))

        print(f"Moved: {file_name} → {destination_folder}")

    print("✅ File organization completed successfully!")

# Run the script

if __name__ == "__main__":

    folder_to_organize = input("Enter the folder path to organize: ")

    organize_files(folder_to_organize)

Face Attendance System

 import cv2

import numpy as np

import face_recognition

import os

import csv

from datetime import datetime

# Folder containing images of known faces

KNOWN_FACES_DIR = "known_faces"

ATTENDANCE_FILE = "attendance.csv"

# Load known face encodings and names

known_encodings = []

known_names = []

for filename in os.listdir(KNOWN_FACES_DIR):

    image_path = os.path.join(KNOWN_FACES_DIR, filename)

    image = face_recognition.load_image_file(image_path)

    encoding = face_recognition.face_encodings(image)[0]

    known_encodings.append(encoding)

    known_names.append(os.path.splitext(filename)[0])  # Remove file extension

# Initialize webcam

video_capture = cv2.VideoCapture(0)

# Function to mark attendance

def mark_attendance(name):

    with open(ATTENDANCE_FILE, "a", newline="") as file:

        writer = csv.writer(file)

        now = datetime.now()

        time_str = now.strftime("%H:%M:%S")

        date_str = now.strftime("%Y-%m-%d")

        writer.writerow([name, date_str, time_str])

# Create CSV file with headers if it doesn't exist

if not os.path.exists(ATTENDANCE_FILE):

    with open(ATTENDANCE_FILE, "w", newline="") as file:

        writer = csv.writer(file)

        writer.writerow(["Name", "Date", "Time"])

# Process video stream

while True:

    ret, frame = video_capture.read()

    if not ret:

        break

    small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25)  # Optimize performance

    rgb_frame = cv2.cvtColor(small_frame, cv2.COLOR_BGR2RGB)

    # Detect faces in the frame

    face_locations = face_recognition.face_locations(rgb_frame)

    face_encodings = face_recognition.face_encodings(rgb_frame, face_locations)

    for encoding, location in zip(face_encodings, face_locations):

        matches = face_recognition.compare_faces(known_encodings, encoding)

        name = "Unknown"

        if True in matches:

            index = matches.index(True)

            name = known_names[index]

            mark_attendance(name)  # Mark attendance in CSV

        # Draw bounding box around detected face

        top, right, bottom, left = [v * 4 for v in location]

        cv2.rectangle(frame, (left, top), (right, bottom), (0, 255, 0), 2)

        cv2.putText(frame, name, (left, top - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)

    cv2.imshow("Face Attendance System", frame)

    if cv2.waitKey(1) & 0xFF == ord("q"):

        break

video_capture.release()

cv2.destroyAllWindows()

Music Playlist Manager

import os

import tkinter as tk

from tkinter import filedialog, messagebox

import pygame

class MusicPlayer:

    def __init__(self, root):

        self.root = root

        self.root.title("Music Playlist Manager 🎵")

        self.root.geometry("500x400")

        

        pygame.init()

        pygame.mixer.init()

        

        self.playlist = []

        self.current_song_index = -1

        self.is_paused = False

        

        # GUI Components

        self.playlist_box = tk.Listbox(root, selectmode=tk.SINGLE, bg="white", fg="black", width=60, height=15)

        self.playlist_box.pack(pady=10)

        btn_frame = tk.Frame(root)

        btn_frame.pack()

        tk.Button(btn_frame, text="Add Song", command=self.add_song).grid(row=0, column=0, padx=5)

        tk.Button(btn_frame, text="Remove Song", command=self.remove_song).grid(row=0, column=1, padx=5)

        tk.Button(btn_frame, text="Play", command=self.play_song).grid(row=0, column=2, padx=5)

        tk.Button(btn_frame, text="Pause", command=self.pause_song).grid(row=0, column=3, padx=5)

        tk.Button(btn_frame, text="Resume", command=self.resume_song).grid(row=0, column=4, padx=5)

        tk.Button(btn_frame, text="Stop", command=self.stop_song).grid(row=0, column=5, padx=5)

        self.current_song_label = tk.Label(root, text="Now Playing: None", fg="blue", font=("Arial", 10, "bold"))

        self.current_song_label.pack(pady=10)

    def add_song(self):

        file_path = filedialog.askopenfilename(filetypes=[("MP3 Files", "*.mp3")])

        if file_path:

            self.playlist.append(file_path)

            self.playlist_box.insert(tk.END, os.path.basename(file_path))

    def remove_song(self):

        selected_index = self.playlist_box.curselection()

        if selected_index:

            index = selected_index[0]

            self.playlist_box.delete(index)

            del self.playlist[index]

    def play_song(self):

        selected_index = self.playlist_box.curselection()

        if selected_index:

            index = selected_index[0]

            self.current_song_index = index

            song_path = self.playlist[index]

            

            pygame.mixer.music.load(song_path)

            pygame.mixer.music.play()

            self.is_paused = False

            self.current_song_label.config(text=f"Now Playing: {os.path.basename(song_path)}")

    def pause_song(self):

        if not self.is_paused:

            pygame.mixer.music.pause()

            self.is_paused = True

    def resume_song(self):

        if self.is_paused:

            pygame.mixer.music.unpause()

            self.is_paused = False

    def stop_song(self):

        pygame.mixer.music.stop()

        self.current_song_label.config(text="Now Playing: None")

# Run the application

if __name__ == "__main__":

    root = tk.Tk()

    app = MusicPlayer(root)

    root.mainloop()