def export_chat_template(chat, filename, db, messages): """ Exports the chat messages to file using templates. @param chat chat data dict, as returned from SkypeDatabase @param filename full path and filename of resulting file, file extension .html|.txt determines file format @param db SkypeDatabase instance @param messages list of message data dicts """ tmpfile, tmpname = None, None # Temporary file for exported messages try: is_html = filename.lower().endswith(".html") parser = skypedata.MessageParser(db, chat=chat, stats=True) namespace = {"db": db, "chat": chat, "messages": messages, "parser": parser} # As HTML and TXT contain statistics in their headers before # messages, write out all messages to a temporary file first, # statistics will be available for the main file after parsing. # Cannot keep all messages in memory at once - very large chats # (500,000+ messages) can take gigabytes. tmpname = util.unique_path("%s.messages" % filename) tmpfile = open(tmpname, "w+") mtemplate = templates.CHAT_MESSAGES_HTML if is_html \ else templates.CHAT_MESSAGES_TXT step.Template(mtemplate, strip=False).stream(tmpfile, namespace) namespace["stats"] = stats = parser.get_collected_stats() namespace.update({ "date1": stats["startdate"].strftime("%d.%m.%Y") if stats.get("startdate") else "", "date2": stats["enddate"].strftime("%d.%m.%Y") if stats.get("enddate") else "", "emoticons_used": [x for x in parser.emoticons_unique if hasattr(emoticons, x)], "message_count": stats.get("messages", 0), }) if is_html: # Collect chat and participant images. namespace.update({"participants": [], "chat_picture_size": None, "chat_picture_raw": None, }) if chat["meta_picture"]: raw = skypedata.fix_image_raw(chat["meta_picture"]) namespace["chat_picture_raw"] = raw namespace["chat_picture_size"] = util.img_size(raw) contacts = dict((c["skypename"], c) for c in db.get_contacts()) partics = dict((p["identity"], p) for p in chat["participants"]) # There can be authors not among participants, and vice versa for author in stats["authors"].union(partics): contact = partics.get(author, {}).get("contact") contact = contact or contacts.get(author, {}) contact = contact or {"identity": author, "name": author} bmp = contact.get("avatar_bitmap") raw = contact.get("avatar_raw_small") or "" raw_large = contact.get("avatar_raw_large") or "" if not raw and not bmp: raw = skypedata.get_avatar_raw(contact, conf.AvatarImageSize) raw = bmp and util.img_wx_to_raw(bmp) or raw if raw: raw_large = raw_large or skypedata.get_avatar_raw( contact, conf.AvatarImageLargeSize) contact["avatar_raw_small"] = raw contact["avatar_raw_large"] = raw_large contact["rank"] = partics.get(author, {}).get("rank") namespace["participants"].append(contact) tmpfile.flush(), tmpfile.seek(0) namespace["message_buffer"] = iter(lambda: tmpfile.read(65536), "") template = templates.CHAT_HTML if is_html else templates.CHAT_TXT with open(filename, "w") as f: step.Template(template, strip=False).stream(f, namespace) finally: if tmpfile: util.try_until(tmpfile.close) if tmpname: util.try_until(lambda: os.unlink(tmpname))
def export_chat_template(chat, filename, db, messages): """ Exports the chat messages to file using templates. @param chat chat data dict, as returned from SkypeDatabase @param filename full path and filename of resulting file, file extension .html|.txt determines file format @param db SkypeDatabase instance @param messages list of message data dicts """ tmpfile, tmpname = None, None # Temporary file for exported messages try: is_html = filename.lower().endswith(".html") parser = skypedata.MessageParser(db, chat=chat, stats=True) namespace = { "db": db, "chat": chat, "messages": messages, "parser": parser } # As HTML and TXT contain statistics in their headers before # messages, write out all messages to a temporary file first, # statistics will be available for the main file after parsing. # Cannot keep all messages in memory at once - very large chats # (500,000+ messages) can take gigabytes. tmpname = util.unique_path("%s.messages" % filename) tmpfile = open(tmpname, "w+") mtemplate = templates.CHAT_MESSAGES_HTML if is_html \ else templates.CHAT_MESSAGES_TXT step.Template(mtemplate, strip=False).stream(tmpfile, namespace) namespace["stats"] = stats = parser.get_collected_stats() namespace.update({ "date1": stats["startdate"].strftime("%d.%m.%Y") if stats.get("startdate") else "", "date2": stats["enddate"].strftime("%d.%m.%Y") if stats.get("enddate") else "", "emoticons_used": [x for x in parser.emoticons_unique if hasattr(emoticons, x)], "message_count": stats.get("messages", 0), }) if is_html: # Collect chat and participant images. namespace.update({ "participants": [], "chat_picture_size": None, "chat_picture_raw": None, }) if chat["meta_picture"]: raw = skypedata.fix_image_raw(chat["meta_picture"]) namespace["chat_picture_raw"] = raw namespace["chat_picture_size"] = util.img_size(raw) contacts = dict((c["skypename"], c) for c in db.get_contacts()) partics = dict((p["identity"], p) for p in chat["participants"]) # There can be authors not among participants, and vice versa for author in stats["authors"].union(partics): contact = partics.get(author, {}).get("contact") contact = contact or contacts.get(author, {}) contact = contact or {"identity": author, "name": author} bmp = contact.get("avatar_bitmap") raw = contact.get("avatar_raw_small") or "" raw_large = contact.get("avatar_raw_large") or "" if not raw and not bmp: raw = skypedata.get_avatar_raw(contact, conf.AvatarImageSize) raw = bmp and util.img_wx_to_raw(bmp) or raw if raw: raw_large = raw_large or skypedata.get_avatar_raw( contact, conf.AvatarImageLargeSize) contact["avatar_raw_small"] = raw contact["avatar_raw_large"] = raw_large contact["rank"] = partics.get(author, {}).get("rank") namespace["participants"].append(contact) tmpfile.flush(), tmpfile.seek(0) namespace["message_buffer"] = iter(lambda: tmpfile.read(65536), "") template = templates.CHAT_HTML if is_html else templates.CHAT_TXT with open(filename, "w") as f: step.Template(template, strip=False).stream(f, namespace) finally: if tmpfile: util.try_until(tmpfile.close) if tmpname: util.try_until(lambda: os.unlink(tmpname))
def export_chat_template(chat, filename, db, messages): """ Exports the chat messages to file using templates. @param chat chat data dict, as returned from SkypeDatabase @param filename full path and filename of resulting file, file extension .html|.txt determines file format @param db SkypeDatabase instance @param messages list of message data dicts """ tmpfile, tmpname = None, None # Temporary file for exported messages try: is_html = filename.lower().endswith(".html") parser = skypedata.MessageParser(db, chat=chat, stats=is_html) namespace = {"db": db, "chat": chat, "messages": messages, "parser": parser} if is_html: # Collect chat and participant images. namespace.update({"participants": [], "chat_picture_size": None, "chat_picture_raw": None, }) if chat["meta_picture"]: raw = skypedata.fix_image_raw(chat["meta_picture"]) imgparser = ImageFile.Parser(); imgparser.feed(raw) img = imgparser.close() namespace.update(chat_picture_size=img.size, chat_picture_raw=raw) for p in chat["participants"]: contact = p["contact"].copy() namespace["participants"].append(contact) contact.update(avatar_raw_small="", avatar_raw_large="") bmp = contact.get("avatar_bitmap") raw = contact.get("avatar_raw_small") raw_large = contact.get("avatar_raw_large") if not raw and not bmp: raw = skypedata.get_avatar_raw(contact, conf.AvatarImageSize) if raw: p["contact"]["avatar_raw_small"] = raw raw = bmp and util.wx_bitmap_to_raw(bmp) or raw if raw: if not raw_large: size_large = conf.AvatarImageLargeSize raw_large = skypedata.get_avatar_raw(contact, size_large) p["contact"]["avatar_raw_large"] = raw_large contact["avatar_raw_small"] = raw contact["avatar_raw_large"] = raw_large # As HTML and TXT contain statistics in their headers before # messages, write out all messages to a temporary file first, # statistics will be available for the main file after parsing. # Cannot keep all messages in memory at once - very large chats # (500,000+ messages) can take gigabytes. tmpname = util.unique_path("%s.messages" % filename) tmpfile = open(tmpname, "w+") mtemplate = templates.CHAT_MESSAGES_HTML if is_html \ else templates.CHAT_MESSAGES_TXT step.Template(mtemplate, strip=False).stream(tmpfile, namespace) namespace["stats"] = stats = parser.get_collected_stats() namespace.update({ "date1": stats["startdate"].strftime("%d.%m.%Y") if stats.get("startdate") else "", "date2": stats["enddate"].strftime("%d.%m.%Y") if stats.get("enddate") else "", "emoticons_used": list(filter(lambda e: hasattr(emoticons, e), parser.emoticons_unique)), "message_count": stats.get("messages", 0), }) tmpfile.flush(), tmpfile.seek(0) namespace["message_buffer"] = iter(lambda: tmpfile.read(65536), "") template = templates.CHAT_HTML if is_html else templates.CHAT_TXT with open(filename, "w") as f: step.Template(template, strip=False).stream(f, namespace) finally: if tmpfile: util.try_until(tmpfile.close) if tmpname: util.try_until(lambda: os.unlink(tmpname))
def export_chat_template(chat, filename, db, messages): """ Exports the chat messages to file using templates. @param chat chat data dict, as returned from SkypeDatabase @param filename full path and filename of resulting file, file extension .html|.txt determines file format @param db SkypeDatabase instance @param messages list of message data dicts """ tmpfile, tmpname = None, None # Temporary file for exported messages try: is_html = filename.lower().endswith(".html") parser = skypedata.MessageParser(db, chat=chat, stats=is_html) namespace = { "db": db, "chat": chat, "messages": messages, "parser": parser } if is_html: # Collect chat and participant images. namespace.update({ "participants": [], "chat_picture_size": None, "chat_picture_raw": None, }) if chat["meta_picture"]: raw = skypedata.fix_image_raw(chat["meta_picture"]) imgparser = ImageFile.Parser() imgparser.feed(raw) img = imgparser.close() namespace.update(chat_picture_size=img.size, chat_picture_raw=raw) for p in chat["participants"]: contact = p["contact"].copy() namespace["participants"].append(contact) contact.update(avatar_raw_small="", avatar_raw_large="") bmp = contact.get("avatar_bitmap") raw = contact.get("avatar_raw_small") raw_large = contact.get("avatar_raw_large") if not raw and not bmp: raw = skypedata.get_avatar_raw(contact, conf.AvatarImageSize) if raw: p["contact"]["avatar_raw_small"] = raw raw = bmp and util.wx_bitmap_to_raw(bmp) or raw if raw: if not raw_large: size_large = conf.AvatarImageLargeSize raw_large = skypedata.get_avatar_raw( contact, size_large) p["contact"]["avatar_raw_large"] = raw_large contact["avatar_raw_small"] = raw contact["avatar_raw_large"] = raw_large # As HTML and TXT contain statistics in their headers before # messages, write out all messages to a temporary file first, # statistics will be available for the main file after parsing. # Cannot keep all messages in memory at once - very large chats # (500,000+ messages) can take gigabytes. tmpname = util.unique_path("%s.messages" % filename) tmpfile = open(tmpname, "w+") mtemplate = templates.CHAT_MESSAGES_HTML if is_html \ else templates.CHAT_MESSAGES_TXT step.Template(mtemplate, strip=False).stream(tmpfile, namespace) namespace["stats"] = stats = parser.get_collected_stats() namespace.update({ "date1": stats["startdate"].strftime("%d.%m.%Y") if stats.get("startdate") else "", "date2": stats["enddate"].strftime("%d.%m.%Y") if stats.get("enddate") else "", "emoticons_used": list( filter(lambda e: hasattr(emoticons, e), parser.emoticons_unique)), "message_count": stats.get("messages", 0), }) tmpfile.flush(), tmpfile.seek(0) namespace["message_buffer"] = iter(lambda: tmpfile.read(65536), "") template = templates.CHAT_HTML if is_html else templates.CHAT_TXT with open(filename, "w") as f: step.Template(template, strip=False).stream(f, namespace) finally: if tmpfile: util.try_until(tmpfile.close) if tmpname: util.try_until(lambda: os.unlink(tmpname))