Encrypted Private Diary App in Python
Local encrypted private diary app in Python.
Example code
Pythonimport 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
More code prompts
View collectionQuestions 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.