How to Impress Your Girlfriend Using Python: 5 AI-Powered Creative Projects to Propose & Surprise

pip install openai python-dotenv requests pillow

OPENAI_API_KEY=your-api-key-here

import os
from openai import OpenAI
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Initialize OpenAI client
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

def generate_personalized_message(recipient_name, occasion, interests, tone="warm"):
    """
    Generate a personalized message using GPT-5.

    Args:
        recipient_name: Name of the person
        occasion: The occasion (birthday, anniversary, appreciation, etc.)
        interests: List of recipient's interests/hobbies
        tone: Message tone (warm, playful, romantic, professional)

    Returns:
        Generated personalized message
    """

    prompt = f"""Create a heartfelt {tone} message for {recipient_name} on the occasion of their {occasion}.

    Context about {recipient_name}:
    - Interests: {', '.join(interests)}

    Requirements:
    - Make it personal and specific to their interests
    - Keep it authentic and genuine (not overly formal)
    - Length: 3-4 sentences
    - Tone: {tone}
    """

    try:
        response = client.chat.completions.create(
            model="gpt-4",  # Use "gpt-5" when available
            messages=[
                {"role": "system", "content": "You are a thoughtful, creative writer who excels at crafting personalized messages."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.8,  # Higher temperature for more creativity
            max_tokens=200
        )

        message = response.choices[0].message.content.strip()
        return message

    except Exception as e:
        return f"Error generating message: {str(e)}"

# Example usage
if __name__ == "__main__":
    recipient = "Sarah"
    occasion = "birthday"
    interests = ["painting", "hiking", "reading sci-fi novels"]

    message = generate_personalized_message(
        recipient_name=recipient,
        occasion=occasion,
        interests=interests,
        tone="warm and playful"
    )

    print(f"\\n🎉 Generated Message:\\n")
    print(message)
    print("\\n")

import os
from openai import OpenAI
from dotenv import load_dotenv
import requests
from PIL import Image
from io import BytesIO
from datetime import datetime

load_dotenv()
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

def create_ai_image(prompt, size="1024x1024", quality="standard", style="vivid"):
    """
    Generate an image using DALL-E 3.

    Args:
        prompt: Detailed description of the image to generate
        size: Image size ("1024x1024", "1024x1792", "1792x1024")
        quality: "standard" or "hd"
        style: "vivid" (hyper-real) or "natural" (more natural)

    Returns:
        Image URL and local file path
    """

    try:
        print(f"🎨 Generating image: '{prompt[:50]}...'")

        response = client.images.generate(
            model="dall-e-3",
            prompt=prompt,
            size=size,
            quality=quality,
            style=style,
            n=1
        )

        image_url = response.data[0].url
        revised_prompt = response.data[0].revised_prompt

        print(f"✨ DALL-E 3 enhanced your prompt to:\\n   '{revised_prompt}'\\n")

        # Download and save the image
        image_response = requests.get(image_url)
        img = Image.open(BytesIO(image_response.content))

        # Save with timestamp
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"ai_art_{timestamp}.png"
        img.save(filename)

        print(f"✅ Image saved as: {filename}")

        return {
            "url": image_url,
            "file": filename,
            "revised_prompt": revised_prompt
        }

    except Exception as e:
        return {"error": str(e)}

# Example usage
if __name__ == "__main__":
    # Create a personalized artwork
    prompt = """A whimsical watercolor painting of a couple stargazing on a hilltop
    under the northern lights. The scene shows them sitting on a blanket with a telescope
    nearby, their silhouettes illuminated by the aurora borealis dancing in shades of
    green and purple above them. Romantic, dreamy atmosphere with twinkling stars."""

    result = create_ai_image(
        prompt=prompt,
        size="1024x1024",
        quality="hd",  # Use "hd" for best quality
        style="vivid"   # More artistic and vibrant
    )

    if "error" not in result:
        print(f"\\n🖼️  View your image at:\\n{result['url']}\\n")

# Romantic portrait
"Oil painting portrait of a couple dancing in the rain in Paris,
 soft street lights reflecting on wet cobblestones, Eiffel Tower
 in background, impressionist style, warm tones"

# Adventure scene
"Digital art of a person kayaking at sunset, vibrant orange and
 pink sky, calm waters reflecting clouds, peaceful atmosphere,
 inspired by Studio Ghibli animation style"

# Pet portrait
"Professional portrait photograph of a golden retriever wearing
 a bow tie, studio lighting, blurred background, joyful expression"

import os
from openai import OpenAI
from dotenv import load_dotenv
from pathlib import Path

load_dotenv()
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

def create_voice_message(recipient, occasion, message_type="heartfelt", voice="nova"):
    """
    Generate a personalized voice message.

    Args:
        recipient: Name of the person
        occasion: The occasion or reason for the message
        message_type: Type of message (heartfelt, funny, encouraging, romantic)
        voice: TTS voice (alloy, echo, fable, onyx, nova, shimmer)

    Returns:
        Path to the audio file
    """

    # Step 1: Generate the script with GPT
    script_prompt = f"""Write a {message_type} voice message script for {recipient}
    for the occasion of {occasion}.

    Requirements:
    - Speak directly to {recipient} (use 'you')
    - 30-45 seconds when spoken (about 100-150 words)
    - Natural, conversational tone
    - Warm and genuine
    - End with a personal touch

    Write ONLY the script to be spoken, no stage directions or notes.
    """

    try:
        print(f"✍️  Generating script for {recipient}...")

        script_response = client.chat.completions.create(
            model="gpt-4",
            messages=[
                {"role": "system", "content": "You write heartfelt, natural-sounding voice message scripts."},
                {"role": "user", "content": script_prompt}
            ],
            temperature=0.8,
            max_tokens=250
        )

        script = script_response.choices[0].message.content.strip()
        print(f"\\n📝 Generated Script:\\n{script}\\n")

        # Step 2: Convert to speech
        print(f"🎙️  Converting to speech with '{voice}' voice...")

        speech_file_path = Path(__file__).parent / f"message_{recipient.lower().replace(' ', '_')}.mp3"

        speech_response = client.audio.speech.create(
            model="tts-1-hd",  # Use "tts-1-hd" for better quality
            voice=voice,
            input=script,
            speed=0.95  # Slightly slower for clarity
        )

        speech_response.stream_to_file(speech_file_path)

        print(f"✅ Voice message saved: {speech_file_path}")

        return {
            "script": script,
            "audio_file": str(speech_file_path),
            "voice": voice
        }

    except Exception as e:
        return {"error": str(e)}

# Example usage
if __name__ == "__main__":
    result = create_voice_message(
        recipient="Mom",
        occasion="Mother's Day",
        message_type="heartfelt and appreciative",
        voice="nova"  # Warm, friendly female voice
    )

    if "error" not in result:
        print(f"\\n🔊 Play your message:\\n{result['audio_file']}\\n")

import os
from openai import OpenAI
from dotenv import load_dotenv
import json

load_dotenv()
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

class AIQuizGame:
    def __init__(self, player_name, interests):
        self.player_name = player_name
        self.interests = interests
        self.score = 0
        self.total_questions = 0

    def generate_question(self, difficulty="medium"):
        """Generate a quiz question based on player's interests."""

        prompt = f"""Generate ONE quiz question for {self.player_name} based on their interests: {', '.join(self.interests)}.

        Difficulty: {difficulty}

        Return a JSON object with this exact structure:
        {{
            "question": "The question text",
            "options": ["Option A", "Option B", "Option C", "Option D"],
            "correct_answer": 0,
            "explanation": "Why this answer is correct"
        }}

        Make it fun, engaging, and related to their interests.
        """

        try:
            response = client.chat.completions.create(
                model="gpt-4",
                messages=[
                    {"role": "system", "content": "You are a creative quiz master who creates engaging, fun questions. Always return valid JSON."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.7,
                response_format={"type": "json_object"}
            )

            question_data = json.loads(response.choices[0].message.content)
            return question_data

        except Exception as e:
            print(f"Error generating question: {e}")
            return None

    def ask_question(self, question_data):
        """Display question and get player's answer."""

        print(f"\\n❓ Question {self.total_questions + 1}:")
        print(f"{question_data['question']}\\n")

        for i, option in enumerate(question_data['options']):
            print(f"   {i + 1}. {option}")

        while True:
            try:
                answer = int(input("\\nYour answer (1-4): ")) - 1
                if 0 <= answer <= 3:
                    break
                print("Please enter 1, 2, 3, or 4")
            except ValueError:
                print("Please enter a number")

        self.total_questions += 1

        if answer == question_data['correct_answer']:
            self.score += 1
            print(f"\\n✅ Correct! {question_data['explanation']}")
        else:
            correct_option = question_data['options'][question_data['correct_answer']]
            print(f"\\n❌ Not quite. The answer was: {correct_option}")
            print(f"   {question_data['explanation']}")

    def generate_personality_insight(self):
        """Generate a fun personality insight based on quiz performance."""

        percentage = (self.score / self.total_questions) * 100

        prompt = f"""Based on this quiz performance, generate a fun, playful personality insight for {self.player_name}:

        - Score: {self.score}/{self.total_questions} ({percentage:.0f}%)
        - Interests: {', '.join(self.interests)}

        Create a 2-3 sentence personality insight that's:
        - Positive and encouraging
        - Relates their score to their interests
        - Fun and lighthearted

        Don't just praise the score - make it creative and personalized!
        """

        try:
            response = client.chat.completions.create(
                model="gpt-4",
                messages=[
                    {"role": "system", "content": "You create fun, encouraging personality insights."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.9
            )

            return response.choices[0].message.content.strip()

        except Exception as e:
            return "You're awesome! Keep learning and exploring your interests!"

    def play(self, num_questions=5):
        """Play the quiz game."""

        print(f"\\n🎮 Welcome to the AI Quiz Game, {self.player_name}!\\n")
        print(f"Let's test your knowledge about: {', '.join(self.interests)}\\n")
        print(f"You'll get {num_questions} questions. Good luck!\\n")
        input("Press Enter to start...")

        for i in range(num_questions):
            question = self.generate_question()
            if question:
                self.ask_question(question)
            else:
                print("\\nOops! Couldn't generate a question. Skipping...")

        # Final results
        print(f"\\n{'='*50}")
        print(f"   🏆 FINAL SCORE: {self.score}/{self.total_questions}")
        print(f"{'='*50}\\n")

        insight = self.generate_personality_insight()
        print(f"💭 Your Personality Insight:\\n{insight}\\n")

# Example usage
if __name__ == "__main__":
    game = AIQuizGame(
        player_name="Alex",
        interests=["astronomy", "coding", "sci-fi movies"]
    )

    game.play(num_questions=5)

import os
from openai import OpenAI
from dotenv import load_dotenv
import json

load_dotenv()
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

class AIPlaylistCurator:
    def __init__(self):
        self.client = client

    def create_playlist(self, mood, favorite_artists=None, genres=None, num_songs=20, occasion=""):
        """
        Create a personalized playlist using AI.

        Args:
            mood: Desired mood (energetic, relaxing, romantic, melancholic, etc.)
            favorite_artists: List of favorite artists for personalization
            genres: Preferred genres
            num_songs: Number of songs to include
            occasion: Special occasion or activity (workout, study, party, etc.)

        Returns:
            Curated playlist with songs and explanation
        """

        prompt = f"""Create a {num_songs}-song playlist with the following criteria:

        Mood: {mood}
        {f"Occasion/Activity: {occasion}" if occasion else ""}
        {f"Favorite Artists: {', '.join(favorite_artists)}" if favorite_artists else ""}
        {f"Preferred Genres: {', '.join(genres)}" if genres else ""}

        Requirements:
        - Mix of well-known and lesser-known songs
        - Good flow and progression
        - If favorite artists provided, include similar artists/style
        - Diverse but cohesive selection

        Return a JSON object with this structure:
        {{
            "playlist_name": "Creative playlist name",
            "description": "2-3 sentence description of the playlist vibe",
            "songs": [
                {{
                    "title": "Song Title",
                    "artist": "Artist Name",
                    "why": "Brief reason for inclusion (1 sentence)"
                }}
            ],
            "curator_note": "Personal note about the playlist"
        }}
        """

        try:
            response = self.client.chat.completions.create(
                model="gpt-4",
                messages=[
                    {"role": "system", "content": "You are an expert music curator with deep knowledge of music across all genres and eras. You create thoughtful, well-flowing playlists."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.8,
                response_format={"type": "json_object"}
            )

            playlist = json.loads(response.choices[0].message.content)
            return playlist

        except Exception as e:
            return {"error": str(e)}

    def print_playlist(self, playlist):
        """Pretty print the playlist."""

        if "error" in playlist:
            print(f"Error: {playlist['error']}")
            return

        print(f"\\n{'='*60}")
        print(f"  🎵  {playlist['playlist_name']}")
        print(f"{'='*60}\\n")

        print(f"{playlist['description']}\\n")

        for i, song in enumerate(playlist['songs'], 1):
            print(f"{i:2d}. {song['title']}")
            print(f"    by {song['artist']}")
            print(f"    💡 {song['why']}\\n")

        print(f"{'='*60}")
        print(f"Curator's Note: {playlist['curator_note']}")
        print(f"{'='*60}\\n")

    def save_playlist(self, playlist, filename="playlist.txt"):
        """Save playlist to a text file."""

        if "error" in playlist:
            return

        with open(filename, 'w', encoding='utf-8') as f:
            f.write(f"{playlist['playlist_name']}\\n")
            f.write(f"{'='*60}\\n\\n")
            f.write(f"{playlist['description']}\\n\\n")

            for i, song in enumerate(playlist['songs'], 1):
                f.write(f"{i}. {song['title']} - {song['artist']}\\n")

            f.write(f"\\n{playlist['curator_note']}\\n")

        print(f"✅ Playlist saved to: {filename}")

# Example usage
if __name__ == "__main__":
    curator = AIPlaylistCurator()

    # Create a personalized playlist
    playlist = curator.create_playlist(
        mood="energetic and uplifting",
        favorite_artists=["Daft Punk", "Tame Impala", "MGMT"],
        genres=["electronic", "indie rock", "synth-pop"],
        num_songs=15,
        occasion="morning workout"
    )

    curator.print_playlist(playlist)
    curator.save_playlist(playlist, "my_workout_mix.txt")

# Study/Focus Playlist
playlist = curator.create_playlist(
    mood="calm and focused",
    genres=["ambient", "lo-fi", "classical"],
    num_songs=20,
    occasion="deep work session"
)

# Romantic Evening
playlist = curator.create_playlist(
    mood="romantic and intimate",
    genres=["jazz", "soul", "acoustic"],
    num_songs=12,
    occasion="candlelit dinner"
)

# Road Trip
playlist = curator.create_playlist(
    mood="adventurous and free",
    favorite_artists=["Fleetwood Mac", "Tom Petty"],
    num_songs=25,
    occasion="long drive"
)

# Track approximate costs
gpt4_cost_per_1k_tokens = 0.03  # Input
dalle3_cost_per_image = 0.04
tts_cost_per_1k_chars = 0.015

# Always set max_tokens to avoid runaway costs
response = client.chat.completions.create(
    model="gpt-4",
    messages=[...],
    max_tokens=500  # Limit output
)

import time
from openai import OpenAI, RateLimitError, APIError

def call_api_with_retry(func, max_retries=3):
    """Retry API calls with exponential backoff."""

    for attempt in range(max_retries):
        try:
            return func()
        except RateLimitError:
            if attempt < max_retries - 1:
                wait_time = 2 ** attempt
                print(f"Rate limited. Waiting {wait_time}s...")
                time.sleep(wait_time)
            else:
                raise
        except APIError as e:
            print(f"API Error: {e}")
            if attempt < max_retries - 1:
                time.sleep(1)
            else:
                raise

# ❌ Vague
"Write a message"

# ✅ Specific
"Write a heartfelt 3-sentence birthday message for my friend Sarah
who loves hiking and photography, in a warm and encouraging tone"

messages = [
    {"role": "system", "content": "You are a professional poet with a specialty in haiku."},
    {"role": "user", "content": "Write a haiku about autumn"}
]

# ✅ GOOD - Use environment variables
import os
from dotenv import load_dotenv

load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

# ❌ BAD - Never hardcode
api_key = "sk-proj-abc123..."  # DON'T DO THIS!

# Add to .gitignore
echo ".env" >> .gitignore

# Sanitize user inputs to prevent prompt injection
def sanitize_input(text, max_length=500):
    # Remove or escape potentially harmful characters
    text = text[:max_length]
    # Add your sanitization logic
    return text