147 lines
4.2 KiB
Python
147 lines
4.2 KiB
Python
"""# Markdown Message Conversion.
|
|
|
|
Conversion script from various messaging formats to markdown.
|
|
|
|
Supported input formats:
|
|
|
|
- [Pidgin/Libpurple](https://pidgin.im/) chat program HTML-based logs. **This
|
|
backend is not actively maintained.**
|
|
- [SyncTech Backup & Restore](https://www.synctech.com.au/sms-backup-restore/)
|
|
XML-based backup format.
|
|
|
|
## Motivation
|
|
|
|
Messaging applications are mostly good at sending real-time messages to other
|
|
people, but they generally do not possess any useful archival features. Most
|
|
messages are write-once read-once, and the apps where built for this use case.
|
|
More and more through, I am attracted to the prospect of archival; of
|
|
understanding who I am and who I _were_ when I wrote those messages.
|
|
|
|
I recently discovered [Obsidian](https://obsidian.md) and liked the prospect of
|
|
cross-referencing my notes with my old chat logs. Libpurple uses HTML logs if
|
|
you haven't configured it to something else (which I haden't).
|
|
|
|
I no longer use IRC or Pidgin as my entire friend group have switched to using
|
|
Matrix.
|
|
|
|
## Usage
|
|
|
|
From the repository root:
|
|
|
|
```bash
|
|
python -m libpurple_to_markdown LOG_DIRECTORY --output OUTPUT_FOLDER
|
|
```
|
|
|
|
It was made specifically for import into Obsidian, so it might not suite your
|
|
purposes, but it shouldn't be too difficult to adjust the formatting code.
|
|
"""
|
|
|
|
import dataclasses
|
|
import datetime
|
|
import logging
|
|
import re
|
|
from collections.abc import Iterable, Iterator
|
|
|
|
from ._version import __version__
|
|
from .data import Message
|
|
|
|
__all__ = ['__version__']
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def datetime_sent(
|
|
chat_start: datetime.datetime,
|
|
message_sent: datetime.time,
|
|
) -> datetime.datetime:
|
|
naive = datetime.datetime.combine(
|
|
chat_start.date(),
|
|
message_sent,
|
|
chat_start.tzinfo,
|
|
)
|
|
if chat_start.time() > message_sent:
|
|
naive = naive + datetime.timedelta(days=1)
|
|
return naive
|
|
|
|
|
|
def format_message_as_citation(out: list[str], msg: Message) -> None:
|
|
out.append(f'{msg.sent_at.date()} {msg.sent_at.time()} [[{msg.sender}]]:')
|
|
out.append('\n')
|
|
for line in msg.text.split('\n'):
|
|
line = re.sub(r'(<[\w ]+>)', r'`\1`', line)
|
|
line = re.sub(r'(\$\$\$)', r'`\1`', line)
|
|
out.append(f'> {line}\n')
|
|
del line
|
|
out.append('\n')
|
|
|
|
|
|
def format_message_as_table(out: list[str], msg: Message) -> None:
|
|
out.append(f'| {msg.sent_at} | [[{msg.sender}]] | ')
|
|
for line in msg.text.split('\n'):
|
|
out.append(f'{line}')
|
|
del line
|
|
out.append('|\n')
|
|
|
|
|
|
def format_messages(messages: list[Message], title: str) -> str:
|
|
out = ['# ', title, '\n\n']
|
|
|
|
as_table = False
|
|
|
|
for msg_idx, msg in enumerate(messages):
|
|
if msg_idx == 0 or messages[msg_idx - 1].sent_at.date() != msg.sent_at.date():
|
|
out.append('---\n')
|
|
out.append(f'## [[{msg.sent_at.date()}]]\n\n')
|
|
if as_table:
|
|
out.append('| sent at | sender | text |\n')
|
|
out.append('| ------- | ------ | ---- |\n')
|
|
|
|
if as_table:
|
|
format_message_as_table(out, msg)
|
|
else:
|
|
format_message_as_citation(out, msg)
|
|
del msg
|
|
|
|
return ''.join(out)
|
|
|
|
|
|
MSG_ADJACENTCY_DIST = datetime.timedelta(minutes=2)
|
|
|
|
|
|
def is_useless_message(msg: Message) -> bool:
|
|
return msg.sender.endswith('<AUTO-REPLY>') or msg.sender == ''
|
|
|
|
|
|
def filter_useless_messages(messages: Iterable[Message]) -> Iterator[Message]:
|
|
for msg in messages:
|
|
if not is_useless_message(msg):
|
|
yield msg
|
|
else:
|
|
print(msg.text)
|
|
|
|
|
|
def is_adjacent_messages(first: Message, second: Message) -> bool:
|
|
return (
|
|
first.sender == second.sender
|
|
and second.sent_at - first.sent_at <= MSG_ADJACENTCY_DIST
|
|
)
|
|
|
|
|
|
def merge_texts(text1: str, text2: str) -> str:
|
|
punctuated = text1.endswith('.?!,:')
|
|
# return text1 + (' ' if punctuated else '. ') + text2
|
|
return text1 + (' ' if punctuated else '. ') + '\n' + text2
|
|
|
|
|
|
def merge_adjacent_messages(messages: Iterable[Message]) -> list[Message]:
|
|
out: list[Message] = []
|
|
for msg in messages:
|
|
if out and is_adjacent_messages(out[-1], msg):
|
|
out[-1] = dataclasses.replace(
|
|
out[-1],
|
|
text=merge_texts(out[-1].text, msg.text),
|
|
)
|
|
else:
|
|
out.append(msg)
|
|
return out
|