Code prompts

Encrypted Private Diary App in Python

Local encrypted private diary app in Python.

Example code

Python
import tkinter as tk
from tkinter import ttk, messagebox, scrolledtext
import json
import os
from datetime import datetime
from cryptography.fernet import Fernet
import hashlib
import base64
from PIL import Image, ImageTk, ImageDraw, ImageFont
import customtkinter as ctk
import threading

# Create necessary directories
if not os.path.exists("diary_data"):
    os.makedirs("diary_data")

class DiaryApp:
    def __init__(self):
        self.key = None
        self.cipher = None
        self.entries = []
        self.current_password = None
        
        # Setup CustomTkinter
        ctk.set_appearance_mode("dark")
        ctk.set_default_color_theme("dark-blue")
        
        self.root = ctk.CTk()
        self.root.title("Lunara • Private Diary")
        self.root.geometry("1000x700")
        self.root.minsize(900, 650)
        
        # Soft night mode colors
        self.colors = {
            "bg": "#0f0c14",
            "accent": "#9d7cff",
            "soft_purple": "#b39dff",
            "text": "#e0d4ff",
            "entry_bg": "#1a1625",
            "mood_bg": "#2a2438"
        }
        
        self.root.configure(fg_color=self.colors["bg"])
        
        # Password setup
        self.setup_password_screen()
        
    def setup_password_screen(self):
        self.clear_window()
        
        frame = ctk.CTkFrame(self.root, fg_color=self.colors["bg"], corner_radius=20)
        frame.pack(padx=40, pady=40, fill="both", expand=True)
        
        # Elegant title
        title = ctk.CTkLabel(frame, text="LUNARA", 
                           font=ctk.CTkFont(family="Helvetica", size=42, weight="bold"),
                           text_color=self.colors["soft_purple"])
        title.pack(pady=(60, 10))
        
        subtitle = ctk.CTkLabel(frame, text="your private sanctuary of moods & fantasies",
                              font=ctk.CTkFont(size=16), text_color="#8a7ab8")
        subtitle.pack(pady=(0, 40))
        
        # Password frame
        pw_frame = ctk.CTkFrame(frame, fg_color=self.colors["entry_bg"], corner_radius=16)
        pw_frame.pack(padx=80, pady=20, fill="x")
        
        ctk.CTkLabel(pw_frame, text="Enter your secret key", 
                    font=ctk.CTkFont(size=14), text_color=self.colors["text"]).pack(pady=(30, 10))
        
        self.pw_entry = ctk.CTkEntry(pw_frame, placeholder_text="your password", 
                                    show="●", width=320, height=50,
                                    font=ctk.CTkFont(size=16),
                                    fg_color="#221c2e", border_color=self.colors["accent"])
        self.pw_entry.pack(pady=10)
        self.pw_entry.bind("<Return>", lambda e: self.unlock_diary())
        
        btn_frame = ctk.CTkFrame(pw_frame, fg_color="transparent")
        btn_frame.pack(pady=30)
        
        ctk.CTkButton(btn_frame, text="Unlock Diary", command=self.unlock_diary,
                     width=180, height=45, corner_radius=12,
                     fg_color=self.colors["accent"], hover_color="#7a5fff",
                     font=ctk.CTkFont(size=15, weight="bold")).pack(side="left", padx=8)
        
        ctk.CTkButton(btn_frame, text="New Diary", command=self.create_new_diary,
                     width=180, height=45, corner_radius=12,
                     fg_color="transparent", border_width=2, border_color="#6b5a8a",
                     font=ctk.CTkFont(size=15)).pack(side="left", padx=8)
        
        footer = ctk.CTkLabel(frame, text="All entries are encrypted locally • Only you can read them",
                            font=ctk.CTkFont(size=12), text_color="#665a7f")
        footer.pack(side="bottom", pady=40)
        
    def create_new_diary(self):
        if not self.pw_entry.get().strip():
            messagebox.showwarning("Empty Key", "Please create a password first.")
            return
            
        self.current_password = self.pw_entry.get()
        self.key = self.derive_key(self.current_password)
        self.cipher = Fernet(self.key)
        
        # Save empty diary
        self.save_entries()
        self.load_main_interface()
        
    def unlock_diary(self):
        password = self.pw_entry.get()
        if not password:
            messagebox.showwarning("Empty", "Please enter your password.")
            return
            
        self.current_password = password
        self.key = self.derive_key(password)
        self.cipher = Fernet(self.key)
        
        try:
            self.load_entries()
            self.load_main_interface()
        except Exception as e:
            messagebox.showerror("Access Denied", "Incorrect password or corrupted diary.")
            self.key = None
            self.cipher = None
            
    def derive_key(self, password):
        # Derive a 32-byte key from password
        salt = b'lunara_diary_salt_2025'
        key = hashlib.pbkdf2_hmac('sha256', password.encode(), salt, 100000, dklen=32)
        return base64.urlsafe_b64encode(key)
        
    def load_entries(self):
        try:
            with open("diary_data/entries.enc", "rb") as f:
                encrypted_data = f.read()
            decrypted = self.cipher.decrypt(encrypted_data)
            self.entries = json.loads(decrypted.decode())
        except FileNotFoundError:
            self.entries = []
        except Exception:
            self.entries = []
            
    def save_entries(self):
        if not self.cipher:
            return
        data = json.dumps(self.entries).encode()
        encrypted = self.cipher.encrypt(data)
        with open("diary_data/entries.enc", "wb") as f:
            f.write(encrypted)
            
    def load_main_interface(self):
        self.clear_window()
        
        # Main container
        main_pane = ctk.CTkPanedWindow(self.root, fg_color=self.colors["bg"])
        main_pane.pack(fill="both", expand=True, padx=15, pady=15)
        
        # Sidebar
        sidebar = ctk.CTkFrame(main_pane, width=240, fg_color=self.colors["entry_bg"], corner_radius=16)
        main_pane.add(sidebar, weight=0)
        
        ctk.CTkLabel(sidebar, text="LUNARA", font=ctk.CTkFont(size=24, weight="bold"),
                    text_color=self.colors["soft_purple"]).pack(pady=(30, 5))
        ctk.CTkLabel(sidebar, text="ambiguous moods • secret fantasies", 
                    font=ctk.CTkFont(size=11), text_color="#7769a0").pack(pady=(0, 30))
        
        # Navigation
        nav_buttons = ["New Entry", "All Records", "Mood Cloud", "Settings"]
        for text in nav_buttons:
            if text == "New Entry":
                btn = ctk.CTkButton(sidebar, text=text, command=self.new_entry_screen,
                                  fg_color=self.colors["accent"], height=42, corner_radius=12,
                                  font=ctk.CTkFont(size=14, weight="bold"))
            else:
                btn = ctk.CTkButton(sidebar, text=text, command=lambda t=text: self.show_message(f"{t} coming soon..."),
                                  fg_color="transparent", border_width=1, border_color="#443a5c", height=42, corner_radius=12)
            btn.pack(pady=6, padx=20, fill="x")
        
        # Main content area
        self.content_frame = ctk.CTkFrame(main_pane, fg_color=self.colors["bg"])
        main_pane.add(self.content_frame, weight=3)
        
        # Welcome header
        header = ctk.CTkFrame(self.content_frame, fg_color="transparent")
        header.pack(fill="x", padx=30, pady=(25, 15))
        
        ctk.CTkLabel(header, text=f"Welcome back, dreamer • {datetime.now().strftime('%B %d, %Y')}",
                    font=ctk.CTkFont(size=18), text_color=self.colors["text"]).pack(side="left")
        
        ctk.CTkButton(header, text="✦ New Entry", command=self.new_entry_screen,
                     width=140, height=38, corner_radius=20,
                     fg_color=self.colors["accent"]).pack(side="right")
        
        # Entries list
        self.entries_frame = ctk.CTkScrollableFrame(self.content_frame, fg_color=self.colors["entry_bg"])
        self.entries_frame.pack(fill="both", expand=True, padx=30, pady=10)
        
        self.refresh_entries()
        
    def refresh_entries(self):
        for widget in self.entries_frame.winfo_children():
            widget.destroy()
            
        if not self.entries:
            empty_label = ctk.CTkLabel(self.entries_frame, 
                                     text="No entries yet.\nYour first fantasy awaits...",
                                     font=ctk.CTkFont(size=16), text_color="#665a7f")
            empty_label.pack(pady=120)
            return
            
        for i, entry in enumerate(reversed(self.entries)):
            self.create_entry_card(entry, i)
            
    def create_entry_card(self, entry, index):
        card = ctk.CTkFrame(self.entries_frame, fg_color=self.colors["mood_bg"], corner_radius=18)
        card.pack(fill="x", padx=15, pady=8)
        
        top_bar = ctk.CTkFrame(card, fg_color="transparent")
        top_bar.pack(fill="x", padx=18, pady=(14, 6))
        
        date_str = datetime.fromisoformat(entry["timestamp"]).strftime("%b %d, %Y • %I:%M %p")
        ctk.CTkLabel(top_bar, text=date_str, font=ctk.CTkFont(size=12), 
                    text_color="#9b8ac4").pack(side="left")
        
        mood_label = ctk.CTkLabel(top_bar, text=entry["mood"], 
                                font=ctk.CTkFont(size=13, weight="bold"),
                                text_color=self.get_mood_color(entry["mood"]))
        mood_label.pack(side="right")
        
        # Content preview
        content = entry["content"]
        preview = content[:120] + "..." if len(content) > 120 else content
        
        content_label = ctk.CTkLabel(card, text=preview, 
                                   font=ctk.CTkFont(size=14), text_color=self.colors["text"],
                                   anchor="w", justify="left", wraplength=680)
        content_label.pack(padx=18, pady=(0, 14), anchor="w")
        
        # Bottom bar
        bottom = ctk.CTkFrame(card, fg_color="transparent")
        bottom.pack(fill="x", padx=18, pady=(0, 14))
        
        ctk.CTkButton(bottom, text="Read Full", width=90, height=28, corner_radius=8,
                     fg_color="#3a2f52", command=lambda e=entry: self.view_entry(e)).pack(side="left")
        
    def get_mood_color(self, mood):
        mood_colors = {
            "melancholy": "#9b7cff",
            "euphoric": "#ff9be3",
            "restless": "#ffcc7a",
            "dreamy": "#7ad1ff",
            "forbidden": "#ff6b8a",
            "ethereal": "#c4a3ff"
        }
        return mood_colors.get(mood.lower(), self.colors["soft_purple"])
        
    def new_entry_screen(self):
        self.clear_content()
        
        form_frame = ctk.CTkFrame(self.content_frame, fg_color=self.colors["entry_bg"], corner_radius=20)
        form_frame.pack(padx=60, pady=40, fill="both", expand=True)
        
        ctk.CTkLabel(form_frame, text="New Entry", font=ctk.CTkFont(size=28, weight="bold"),
                    text_color=self.colors["soft_purple"]).pack(pady=(30, 5))
        
        # Mood selector
        ctk.CTkLabel(form_frame, text="Mood", font=ctk.CTkFont(size=15)).pack(anchor="w", padx=50, pady=(25, 5))
        
        moods = ["melancholy", "euphoric", "restless", "dreamy", "forbidden", "ethereal"]
        self.mood_var = tk.StringVar(value=moods[0])
        
        mood_combo = ctk.CTkComboBox(form_frame, values=moods, variable=self.mood_var,
                                   width=300, height=40, corner_radius=12,
                                   font=ctk.CTkFont(size=14))
        mood_combo.pack(padx=50, pady=(0, 20), anchor="w")
        
        # Content
        ctk.CTkLabel(form_frame, text="Your fantasy or ambiguous thought", 
                    font=ctk.CTkFont(size=15)).pack(anchor="w", padx=50, pady=(10, 5))
        
        self.content_text = ctk.CTkTextbox(form_frame, height=280, corner_radius=12,
                                         font=ctk.CTkFont(size=15), wrap="word")
        self.content_text.pack(padx=50, pady=8, fill="x")
        
        # Save button
        btn_frame = ctk.CTkFrame(form_frame, fg_color="transparent")
        btn_frame.pack(pady=30)
        
        ctk.CTkButton(btn_frame, text="✧ Save to Eternity", command=self.save_new_entry,
                     width=220, height=52, corner_radius=30,
                     fg_color=self.colors["accent"], font=ctk.CTkFont(size=16, weight="bold")).pack()
        
        ctk.CTkButton(btn_frame, text="Cancel", command=self.load_main_interface,
                     width=120, height=42, corner_radius=30,
                     fg_color="transparent", border_width=2).pack(pady=(12, 0))
        
    def save_new_entry(self):
        content = self.content_text.get("1.0", "end").strip()
        if not content:
            messagebox.showwarning("Empty", "Write something before saving...")
            return
            
        new_entry = {
            "timestamp": datetime.now().isoformat(),
            "mood": self.mood_var.get(),
            "content": content
        }
        
        self.entries.append(new_entry)
        self.save_entries()
        messagebox.showinfo("Saved", "Your secret has been encrypted and stored safely.")
        self.load_main_interface()
        
    def view_entry(self, entry):
        self.clear_content()
        
        view_frame = ctk.CTkFrame(self.content_frame, fg_color=self.colors["entry_bg"], corner_radius=20)
        view_frame.pack(padx=50, pady=40, fill="both", expand=True)
        
        date_str = datetime.fromisoformat(entry["timestamp"]).strftime("%A, %B %d, %Y at %I:%M %p")
        
        ctk.CTkLabel(view_frame, text=date_str, font=ctk.CTkFont(size=14),
                    text_color="#9b8ac4").pack(pady=(35, 5))
        
        ctk.CTkLabel(view_frame, text=entry["mood"].upper(), 
                    font=ctk.CTkFont(size=22, weight="bold"),
                    text_color=self.get_mood_color(entry["mood"])).pack(pady=(0, 25))
        
        content_box = ctk.CTkTextbox(view_frame, height=380, font=ctk.CTkFont(size=16),
                                   fg_color=self.colors["bg"], wrap="word")
        content_box.pack(padx=60, pady=10, fill="both", expand=True)
        content_box.insert("1.0", entry["content"])
        content_box.configure(state="disabled")
        
        ctk.CTkButton(view_frame, text="Return to Diary", command=self.load_main_interface,
                     width=200, height=45, corner_radius=25).pack(pady=30)
        
    def clear_window(self):
        for widget in self.root.winfo_children():
            widget.destroy()
            
    def clear_content(self):
        for widget in self.content_frame.winfo_children():
            widget.destroy()
            
    def show_message(self, msg):
        messagebox.showinfo("Lunara", msg)
        
    def run(self):
        self.root.mainloop()

# Make it directly runnable
if __name__ == "__main__":
    try:
        import customtkinter as ctk
        from PIL import Image, ImageTk
    except ImportError:
        print("Installing required packages...")
        import subprocess
        subprocess.check_call(["pip", "install", "customtkinter", "pillow", "cryptography"])
        print("Packages installed. Please restart the application.")
        exit()
        
    app = DiaryApp()
    print("✧ Lunara Private Diary is opening in elegant night mode...")
    print("Your moods and fantasies will be encrypted with Fernet.")
    app.run()

Prompt

Use Python to write a complete local private diary app that can encrypt and save users' ambiguous moods and fantasy records. The interface design is elegant with soft night mode. The code must be directly runnable.

Generator starting settings

Model
Uncensored Code
Mode
chat
View collection

Questions about this prompt

What is this AI code prompt about?

This prompt focuses on “Encrypted Private Diary App in Python”: Local encrypted private diary app in Python. It is ready to use for code generation on HackAIGC.

How do I use this prompt on HackAIGC?

Open the prompt, tap Use prompt or Copy prompt, then run it with your preferred model and settings.

What approach does this code prompt use?

The brief for “Encrypted Private Diary App in Python” includes fantasy, elegant, soft cues. Edit the prompt to change the tone, structure, or level of detail.

Can I edit this prompt before generating?

Yes. Copy the prompt text, modify details, then generate again on HackAIGC.