redplanet
/
whatsapp-archiver
1
0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
2 Revīzijas
1 Atzars
229 KiB
 
Koks: 8fc33808b1
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no '8fc33808b1'
${ noResults }
whatsapp-archiver/whatsapp_exporter.py

581 rinda
22 KiB
Neapstrādāts Vainot Vēsture 

  1. # WhatsApp Chat Viewer

  2. #

  3. # This script reads a WhatsApp ChatStorage.sqlite database and associated media files

  4. # to generate a browsable HTML archive of chat conversations.

  5. #

  6. # Author: Gemini

  7. # Date: September 7, 2025

  8. # Version: 1.3 - Improved name resolution to avoid displaying encoded strings.

  9. 

  10. import sqlite3

  11. import os

  12. import argparse

  13. import html

  14. from datetime import datetime, timedelta

  15. import shutil

  16. 

  17. # WhatsApp's epoch starts on 2001-01-01 00:00:00 (Core Data timestamp)

  18. WHATSAPP_EPOCH = datetime(2001, 1, 1)

  19. 

  20. def convert_whatsapp_timestamp(ts):

  21.     """Converts WhatsApp's Core Data timestamp to a human-readable string."""

  22.     if not ts:

  23.         return ""

  24.     try:

  25.         # Timestamps are seconds since the WhatsApp epoch

  26.         dt = WHATSAPP_EPOCH + timedelta(seconds=ts)

  27.         return dt.strftime('%Y-%m-%d %H:%M:%S')

  28.     except (ValueError, TypeError):

  29.         return "Invalid date"

  30. 

  31. def get_media_tag(media_path, output_dir):

  32.     """Generates the appropriate HTML tag for a given media file and copies it."""

  33.     if not media_path:

  34.         return ""

  35. 

  36.     # Path in the DB is often relative like 'Media/WhatsApp Images/IMG-...'

  37.     test_path = os.path.join(output_dir, 'Message', media_path)

  38.     full_media_path = ''

  39.     if not os.path.exists(test_path):

  40.         return f'<div class="media-missing">Media not found: {html.escape(test_path)}</div>'

  41.     

  42.     full_media_path = os.path.join('Message', media_path)

  43.     # remove ./ in the beginning if present

  44.     full_media_path = full_media_path.lstrip('./')

  45. 

  46.     ext = os.path.splitext(media_path)[1].lower()

  47.     

  48.     if ext in ['.jpg', '.jpeg', '.png', '.gif', '.webp']:

  49.         return f'<img src="../{full_media_path}"  loading="lazy" alt="Image" class="media-item">'

  50.     elif ext in ['.mp4', '.mov', '.webm']:

  51.         return f'<video controls src="../{full_media_path}" class="media-item" loading="lazy"></video>'

  52.     elif ext in ['.mp3', '.ogg', '.opus', '.m4a']:

  53.         return f'<audio controls src="../{full_media_path}" loading="lazy"></audio>'

  54.     else:

  55.         return f'<a href="../{full_media_path}" target="_blank">View Media: {os.path.basename(media_path)}</a>'

  56. 

  57. def generate_html_chat(db_path, media_path, output_dir, chat_id, chat_name, is_group, contact_jid):

  58.     """Generates an HTML file for a single chat session."""

  59.     conn = sqlite3.connect(db_path)

  60.     cursor = conn.cursor()

  61. 

  62.     # Updated query to fetch more potential name fields (like ZFIRSTNAME) to find the best one.

  63.     query = """

  64.     SELECT

  65.         m.ZISFROMME,

  66.         m.ZTEXT,

  67.         m.ZMESSAGEDATE,

  68.         m.ZFROMJID,

  69.         g.ZCONTACTNAME AS GroupMemberContactName,

  70.         cs.ZPARTNERNAME AS ChatPartnerName,

  71.         p.ZPUSHNAME AS ProfilePushName,

  72.         mi.ZMEDIALOCALPATH,

  73.         cs.ZCONTACTJID AS ChatJID

  74.     FROM

  75.         ZWAMESSAGE m

  76.     LEFT JOIN

  77.         ZWAGROUPMEMBER g ON m.ZGROUPMEMBER = g.Z_PK

  78.     LEFT JOIN

  79.         ZWACHATSESSION cs ON m.ZCHATSESSION = cs.Z_PK

  80.     LEFT JOIN

  81.         ZWAPROFILEPUSHNAME p ON m.ZFROMJID = p.ZJID

  82.     LEFT JOIN

  83.         ZWAMEDIAITEM mi ON m.ZMEDIAITEM = mi.Z_PK

  84.     WHERE

  85.         m.ZCHATSESSION = ?

  86.     ORDER BY

  87.         m.ZMESSAGEDATE ASC;

  88.     """

  89. 

  90.     cursor.execute(query, (chat_id,))

  91.     messages = cursor.fetchall()

  92.     conn.close()

  93. 

  94.     if not messages:

  95.         print(f"No messages found for chat: {chat_name}")

  96.         return

  97. 

  98.     # Sanitize contact_jid for a unique and safe filename

  99.     if contact_jid:

  100.         safe_filename = "".join(c if c.isalnum() else "_" for c in contact_jid)

  101.     else:

  102.         # Fallback to chat_id if contact_jid is not available

  103.         safe_filename = str(chat_id)

  104. 

  105.     chats_dir = os.path.join(output_dir, "chats")

  106.     os.makedirs(chats_dir, exist_ok=True)

  107.     html_filename = os.path.join(chats_dir, f"{safe_filename}.html")

  108. 

  109.     with open(html_filename, 'w', encoding='utf-8') as f:

  110.         f.write(f"""

  111.     <!DOCTYPE html>

  112.     <html lang="en">

  113.     <head>

  114.         <meta charset="UTF-8">

  115.         <meta name="viewport" content="width=device-width, initial-scale=1.0">

  116.         <title>Chat with {html.escape(chat_name)}</title>

  117.         <style>

  118.         body {{

  119.             font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;

  120.             background-color: #e5ddd5;

  121.             margin: 0;

  122.             padding: 20px;

  123.             color: #111b21;

  124.             min-height: 100vh;

  125.             box-sizing: border-box;

  126.         }}

  127.         .chat-container {{

  128.             max-width: 800px;

  129.             margin: auto;

  130.             background-image: url('../current_wallpaper.jpg');

  131.             background-size: auto 100%;

  132.             background-attachment: fixed;

  133.             background-position: center;

  134.             border-radius: 8px;

  135.             box-shadow: 0 1px 1px 0 rgba(0,0,0,0.06), 0 2px 5px 0 rgba(0,0,0,0.06);

  136.             overflow: hidden;

  137.         }}

  138.         .chat-header {{

  139.             background-color: #008069;

  140.             color: white;

  141.             padding: 15px 20px;

  142.             font-size: 1.2em;

  143.             text-align: center;

  144.         }}

  145. 

  146. 

  147.         .chat-header-id {{

  148.             font-size: 0.7em;

  149.             opacity: 0.8;

  150.             margin-top: 5px;

  151.         }}

  152.         

  153.         .chat-box {{

  154.             padding: 20px;

  155.             display: flex;

  156.             flex-direction: column;

  157.             gap: 12px;

  158.         }}

  159.         .message {{

  160.             padding: 8px 12px;

  161.             border-radius: 18px;

  162.             max-width: 70%;

  163.             word-wrap: break-word;

  164.             position: relative;

  165.         }}

  166.         .message.sent {{

  167.             background-color: #dcf8c6;

  168.             align-self: flex-end;

  169.             border-bottom-right-radius: 4px;

  170.         }}

  171.         .message.received {{

  172.             background-color: #ffffff;

  173.             align-self: flex-start;

  174.             border-bottom-left-radius: 4px;

  175.         }}

  176.         .sender-name {{

  177.             font-weight: bold;

  178.             font-size: 0.9em;

  179.             color: #005c4b;

  180.             margin-bottom: 4px;

  181.         }}

  182.         .timestamp {{

  183.             font-size: 0.75em;

  184.             color: #667781;

  185.             margin-top: 5px;

  186.             text-align: right;

  187.         }}

  188.         .media-item {{

  189.             max-width: 100%;

  190.             border-radius: 8px;

  191.             margin-top: 5px;

  192.             display: block;

  193.         }}

  194.         .media-missing {{

  195.             font-style: italic;

  196.             color: #888;

  197.             background-color: #fcebeb;

  198.             border: 1px solid #f5c6cb;

  199.             padding: 10px;

  200.             border-radius: 8px;

  201.         }}

  202.         </style>

  203.     </head>

  204.     <body>

  205.         <div class="chat-container">

  206.         <div class="chat-header">

  207.             {html.escape(chat_name)}

  208.             <div class="chat-header-id">{contact_jid}</div>

  209.         </div>

  210.         <div class="chat-box">

  211.         """)

  212. 

  213.         # Write messages

  214.         for is_from_me, text, timestamp, from_jid, group_member_contact_name, chat_partner_name, profile_push_name, media_local_path, contact_jid in messages:

  215.             msg_class = "sent" if is_from_me else "received"

  216.             

  217.             f.write(f'<div class="message {msg_class}">')

  218. 

  219.             # Determine and display the sender's name for incoming messages

  220.             if not is_from_me:

  221.                 # Prioritize group member contact name for group chats

  222.                 if is_group:

  223.                     # Try names in order of preference, avoiding encoded-looking strings

  224.                     potential_names = [

  225.                         group_member_contact_name,

  226.                         profile_push_name,

  227.                         from_jid,

  228.                         chat_partner_name,

  229.                     ]

  230.                     

  231.                     # Filter out None values and strings that look like they're encoded

  232.                     valid_names = [name for name in potential_names if name and not (

  233.                         name.startswith('CK') and any(c.isupper() for c in name[2:]) and '=' in name

  234.                     )]

  235.                     

  236.                     sender_name = next((name for name in valid_names), "Unknown")

  237.                 else:

  238.                     # For individual chats, prefer partner name or push name

  239.                     sender_name = chat_partner_name or profile_push_name or from_jid or "Unknown"

  240.                 

  241.                 f.write(f'<div class="sender-name">{html.escape(str(sender_name))}</div>')

  242. 

  243.             if text:

  244.                 # Replace newline characters with <br> tags for proper display

  245.                 escaped_text = html.escape(text)

  246.                 f.write(f'<div>{escaped_text.replace(chr(10), "<br>")}</div>')

  247.             

  248.             if media_local_path:

  249.                 # print("Media path:", media_local_path)

  250.                 f.write(get_media_tag(media_local_path, output_dir))

  251. 

  252.             f.write(f'<div class="timestamp">{convert_whatsapp_timestamp(timestamp)}</div>')

  253.             f.write('</div>')

  254. 

  255.         f.write("""

  256.         </div>

  257.     </div>

  258. </body>

  259. </html>

  260.         """)

  261. 

  262.     print(f"Successfully generated HTML for: {chat_name}")

  263. 

  264. 

  265. # Step: iPhone backup manifest.db processing

  266. def process_iphone_backup(backup_path, output_dir):

  267.     """

  268.     Processes the iPhone backup manifest.db, extracts WhatsApp shared files, and recreates the file structure in output_dir.

  269.     """

  270.     manifest_db_path = os.path.join(backup_path, 'Manifest.db')

  271.     if not os.path.exists(manifest_db_path):

  272.         print(f"Manifest.db not found in backup path: {manifest_db_path}")

  273.         return

  274. 

  275.     # Connect to manifest.db and extract WhatsApp shared files

  276.     conn = sqlite3.connect(manifest_db_path)

  277.     cursor = conn.cursor()

  278.     cursor.execute("SELECT fileID, domain, relativePath FROM Files WHERE domain = ?", ('AppDomainGroup-group.net.whatsapp.WhatsApp.shared',))

  279.     files = cursor.fetchall()

  280.     print(f"Found {len(files)} WhatsApp shared files in manifest.db.")

  281.     # Prepare to recreate file structure

  282.     for fileID, domain, relativePath in files:

  283.         src_file = os.path.join(backup_path, fileID[:2], fileID)

  284.         dest_file = os.path.join(output_dir, relativePath)

  285.         os.makedirs(os.path.dirname(dest_file), exist_ok=True)

  286.         if os.path.exists(src_file):

  287.             if not os.path.exists(dest_file):

  288.                 try:

  289.                     shutil.copy2(src_file, dest_file)

  290.                 except Exception as e:

  291.                     print(f"Error copying {src_file} to {dest_file}: {e}")

  292.         else:

  293.             print(f"Source file missing: {src_file}")

  294. 

  295. 

  296. def main():

  297.     parser = argparse.ArgumentParser(description="WhatsApp Chat Exporter")

  298.     parser.add_argument("--output", default="_html_export", help="Directory to save the HTML files.")

  299.     parser.add_argument("--backup-path", default=None, help="Path to iPhone backup directory (for manifest.db processing)")

  300.     args = parser.parse_args()

  301. 

  302.     if args.backup_path:

  303.         process_iphone_backup(args.backup_path, args.output)

  304.         # Use backup paths for archive creation

  305.         db_path = os.path.join(args.output, "ChatStorage.sqlite")

  306.         media_path = os.path.join(args.output, "Message/")

  307.     else:

  308.         parser.add_argument("db_path", help="Path to the ChatStorage.sqlite file.")

  309.         parser.add_argument("media_path", help="Path to the root 'Media' directory.")

  310.         args = parser.parse_args()

  311.         db_path = args.db_path

  312.         media_path = args.media_path

  313. 

  314.     if not os.path.exists(db_path):

  315.         print(f"Error: Database file not found at '{db_path}'")

  316.         return

  317. 

  318.     if not os.path.exists(media_path):

  319.         print(f"Error: Media directory not found at '{media_path}'")

  320.         return

  321. 

  322.     os.makedirs(args.output, exist_ok=True)

  323. 

  324.     conn = sqlite3.connect(db_path)

  325.     cursor = conn.cursor()

  326.     

  327.     # Get all chats, joining with ZWAPROFILEPUSHNAME and using COALESCE to get the best possible name.

  328.     cursor.execute("""

  329.         SELECT 

  330.             cs.Z_PK, 

  331.             COALESCE(p.ZPUSHNAME, cs.ZPARTNERNAME) AS ChatName, 

  332.             cs.ZCONTACTJID,

  333.             cs.ZMESSAGECOUNTER,

  334.             MIN(m.ZMESSAGEDATE) as FirstMessageDate,

  335.             MAX(m.ZMESSAGEDATE) as LastMessageDate,

  336.             COALESCE(gi.ZPICTUREPATH, pic.ZPATH) AS AvatarPath

  337.         FROM 

  338.             ZWACHATSESSION cs

  339.         LEFT JOIN 

  340.             ZWAPROFILEPUSHNAME p ON cs.ZCONTACTJID = p.ZJID

  341.         LEFT JOIN

  342.             ZWAMESSAGE m ON cs.Z_PK = m.ZCHATSESSION

  343.         LEFT JOIN

  344.             ZWAGROUPINFO gi ON cs.ZGROUPINFO = gi.Z_PK

  345.         LEFT JOIN

  346.             ZWAPROFILEPICTUREITEM pic ON cs.ZCONTACTJID = pic.ZJID

  347.         WHERE

  348.             cs.ZCONTACTJID NOT LIKE '%@status'

  349.         GROUP BY

  350.             cs.Z_PK, ChatName, cs.ZCONTACTJID, cs.ZMESSAGECOUNTER, AvatarPath

  351.         ORDER BY 

  352.             LastMessageDate DESC NULLS LAST, ChatName

  353.     """)

  354.     chats = cursor.fetchall()

  355.     conn.close()

  356. 

  357.     print(f"Found {len(chats)} chats to export.")

  358. 

  359.     index_path = os.path.join(args.output, "whatsapp-chats.html")

  360.     with open(index_path, 'w', encoding='utf-8') as index_f:

  361.         index_f.write(f"""

  362.         <!DOCTYPE html>

  363.         <html lang="en">

  364.         <head>

  365.             <meta charset="UTF-8">

  366.             <meta name="viewport" content="width=device-width, initial-scale=1.0">

  367.             <title>WhatsApp Chat Export</title>

  368.             <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path fill='%23128C7E' d='M12 2C6.5 2 2 6.5 2 12c0 2 .6 3.9 1.6 5.4L2 22l4.6-1.6c1.5 1 3.4 1.6 5.4 1.6 5.5 0 10-4.5 10-10S17.5 2 12 2z'/></svg>">

  369.             <style>

  370.             body {{ 

  371.                 font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif; 

  372.                 background-color: #f4f4f9; 

  373.                 margin: 0;

  374.                 padding: 20px;

  375.                 min-height: 100vh;

  376.             }}

  377.             .header {{

  378.                 background-color: #128C7E;

  379.                 color: white;

  380.                 padding: 20px;

  381.                 margin: -20px -20px 20px -20px;

  382.                 text-align: center;

  383.                 box-shadow: 0 2px 4px rgba(0,0,0,0.1);

  384.             }}

  385.             .header h1 {{

  386.                 margin: 0;

  387.                 font-size: 1.8em;

  388.             }}

  389.             .export-info {{

  390.                 color: rgba(255,255,255,0.9);

  391.                 margin-top: 8px;

  392.                 font-size: 0.9em;

  393.             }}

  394.             .container {{ 

  395.                 max-width: 700px; 

  396.                 margin: auto;

  397.                 background: white;

  398.                 padding: 20px;

  399.                 border-radius: 12px;

  400.                 box-shadow: 0 2px 8px rgba(0,0,0,0.1);

  401.             }}

  402.             ul {{ list-style-type: none; padding: 0; }}

  403.             li {{ margin: 8px 0; }}

  404.             .chat-entry {{ 

  405.                 text-decoration: none; 

  406.                 color: #0056b3; 

  407.                 background-color: #fff;

  408.                 padding: 12px;

  409.                 border-radius: 8px;

  410.                 display: flex;

  411.                 align-items: center;

  412.                 box-shadow: 0 2px 4px rgba(0,0,0,0.1);

  413.                 transition: all 0.2s ease-in-out;

  414.                 gap: 12px;

  415.             }}

  416.             a.chat-entry:hover {{ 

  417.                 background-color: #e9ecef; 

  418.                 transform: translateY(-2px); 

  419.                 box-shadow: 0 4px 8px rgba(0,0,0,0.15); 

  420.             }}

  421.             .chat-entry.inactive {{

  422.                 color: #999;

  423.                 background-color: #f8f9fa;

  424.                 cursor: default;

  425.             }}

  426.             .chat-avatar {{

  427.                 width: 48px;

  428.                 height: 48px;

  429.                 border-radius: 50%;

  430.                 background-size: cover;

  431.                 background-position: center;

  432.                 flex-shrink: 0;

  433.             }}

  434.             .chat-avatar.default-individual {{

  435.                 background-color: #DFE5E7;

  436.                 background-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="%23999"><path d="M12 12c2.21 0 4-1.79 4-4s-1.79-4-4-4-4 1.79-4 4 1.79 4 4 4zm0 2c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4z"/></svg>');

  437.             }}

  438.             .chat-avatar.default-group {{

  439.                 background-color: #DFE5E7;

  440.                 background-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="%23999"><path d="M16 11c1.66 0 2.99-1.34 2.99-3S17.66 5 16 5c-1.66 0-3 1.34-3 3s1.34 3 3 3zm-8 0c1.66 0 2.99-1.34 2.99-3S9.66 5 8 5C6.34 5 5 6.34 5 8s1.34 3 3 3zm0 2c-2.33 0-7 1.17-7 3.5V19h14v-2.5c0-2.33-4.67-3.5-7-3.5zm8 0c-.29 0-.62.02-.97.05 1.16.84 1.97 1.97 1.97 3.45V19h6v-2.5c0-2.33-4.67-3.5-7-3.5z"/></svg>');

  441.             }}

  442.             .chat-info {{

  443.                 flex-grow: 1;

  444.                 min-width: 0;

  445.             }}

  446.             .message-count {{

  447.                 background-color: #128C7E;

  448.                 color: white;

  449.                 padding: 4px 8px;

  450.                 border-radius: 12px;

  451.                 font-size: 0.85em;

  452.                 min-width: 24px;

  453.                 text-align: center;

  454.             }}

  455.             .message-count.zero {{

  456.                 background-color: #ddd;

  457.             }}

  458.             .chat-info {{

  459.                 display: flex;

  460.                 flex-direction: column;

  461.                 gap: 4px;

  462.             }}

  463.             .chat-name {{

  464.                 font-weight: 500;

  465.             }}

  466.             .date-range {{

  467.                 font-size: 0.8em;

  468.                 color: #667781;

  469.             }}

  470.             .chat-entry.inactive .date-range {{

  471.                 color: #999;

  472.             }}

  473.             </style>

  474.         </head>

  475.         <body>

  476.             <div class="header">

  477.             <h1>WhatsApp Chat Export</h1>

  478.             <div class="export-info">Exported on {datetime.now().strftime('%Y-%m-%d %H:%M')}</div>

  479.             </div>

  480.             <div class="container">

  481.             <ul>

  482.         """)

  483.         for chat_id, chat_name, contact_jid, message_count, first_message_date, last_message_date, avatar_path in chats:

  484.             if not chat_name:

  485.                 chat_name = f"Unknown Chat ({contact_jid or chat_id})"

  486.             full_avatar_path = avatar_path if avatar_path and os.path.isabs(avatar_path) else os.path.join(args.output, avatar_path) if avatar_path else None

  487. 

  488.             # Find all file paths in args.output that start with full_avatar_path

  489.             matching_files = []

  490.             if full_avatar_path:

  491.                 for root, dirs, files in os.walk(args.output):

  492.                     for file in files:

  493.                         file_path = os.path.join(root, file)

  494.                         if file_path.startswith(full_avatar_path):

  495.                             matching_files.append(file_path)

  496. 

  497.             # Use the first matching file if available

  498.             if matching_files:

  499.                 avatar_path = os.path.relpath(matching_files[0], args.output)

  500.                 full_avatar_path = matching_files[0]

  501.             

  502.             # A group chat JID typically ends with '@g.us'

  503.             is_group = contact_jid and '@g.us' in contact_jid

  504.             

  505.             # Sanitize contact_jid for a unique and safe filename

  506.             if contact_jid:

  507.                 safe_filename = "".join(c if c.isalnum() else "_" for c in contact_jid)

  508.             else:

  509.                 # Fallback to chat_id if contact_jid is not available

  510.                 safe_filename = str(chat_id)

  511. 

  512.             # Add default avatar based on chat type

  513.             if avatar_path and os.path.exists(full_avatar_path):

  514.                 avatar_html = f'<div class="chat-avatar" style="background-image: url(\'{avatar_path}\');"></div>'

  515.             else:

  516.                 avatar_html = f'<div class="chat-avatar default-{"group" if is_group else "individual"}"></div>'

  517.             

  518.             # Format date range

  519.             date_range = ""

  520.             if message_count > 0 and first_message_date and last_message_date:

  521.                 first_date = convert_whatsapp_timestamp(first_message_date).split()[0]  # Get just the date part

  522.                 last_date = convert_whatsapp_timestamp(last_message_date).split()[0]

  523.                 if first_date == last_date:

  524.                     date_range = first_date

  525.                 else:

  526.                     date_range = f"{first_date} – {last_date}"

  527.             

  528.             if message_count > 0:

  529.                 # Generate chat HTML only for chats with messages

  530.                 generate_html_chat(db_path, media_path, args.output, chat_id, chat_name, is_group, contact_jid)

  531. 

  532.                 # Clickable entry with link

  533.                 index_f.write(

  534.                     f'<li><a class="chat-entry" href="chats/{html.escape(safe_filename)}.html">'

  535.                     f'{avatar_html}'

  536.                     f'<div class="chat-info">'

  537.                     f'<span class="chat-name">{html.escape(str(chat_name))}</span>'

  538.                     f'<span class="date-range">{date_range}</span>'

  539.                     f'</div>'

  540.                     f'<span class="message-count">{message_count:,}</span>'

  541.                     f'</a></li>'

  542.                 )

  543.             else:

  544.                 # Non-clickable entry for empty chats

  545.                 index_f.write(

  546.                     f'<li><div class="chat-entry inactive">'

  547.                     f'{avatar_html}'

  548.                     f'<div class="chat-info">'

  549.                     f'<span class="chat-name">{html.escape(str(chat_name))}</span>'

  550.                     f'<span class="date-range">No messages</span>'

  551.                     f'</div>'

  552.                     f'<span class="message-count zero">0</span>'

  553.                     f'</div></li>'

  554.                 )

  555. 

  556.         index_f.write("</ul></div></body></html>")

  557. 

  558.     # Create a simple redirect index.html

  559.     redirect_index = os.path.join(args.output, "index.html")

  560.     with open(redirect_index, 'w', encoding='utf-8') as f:

  561.         f.write(f"""<!DOCTYPE html>

  562. <html>

  563. <head>

  564.     <meta http-equiv="refresh" content="0; url=whatsapp-chats.html">

  565.     <title>Redirecting to WhatsApp Chats...</title>

  566. </head>

  567. <body>

  568.     <p>Redirecting to <a href="whatsapp-chats.html">WhatsApp Chats</a>...</p>

  569. </body>

  570. </html>""")

  571. 

  572.     print(f"\nExport complete!")

  573.     print(f"View your chats by opening either of these files in your browser:")

  574.     print(f"  • {os.path.abspath(index_path)}")

  575.     print(f"  • {os.path.abspath(redirect_index)}")

  576. 

  577. 

  578. if __name__ == "__main__":

  579.     main()