arcanechat-tui 0.11.0__py3-none-any.whl

arcanechat_tui/conversation.py

@@ -0,0 +1,127 @@
+"""Conversation area widget"""
+
+from datetime import datetime
+from typing import Any, Optional, Tuple
+
+import urwid
+from deltachat2 import (
+    Client,
+    Message,
+    MessageState,
+    SpecialContactId,
+    SystemMessageType,
+)
+
+from .lazylistwaker import LazyListWalker
+from .util import shorten_text
+
+
+class DayMarker(urwid.Columns):
+    """Day marker separating messages by day"""
+
+    def __init__(self, timestamp: int):
+        date = datetime.utcfromtimestamp(timestamp)  # timestamp is in local time already
+        date_format = "%b %d, %Y"
+        date_label = urwid.Text(("date", date.strftime(f"\n  {date_format}  ")))
+        divider = urwid.AttrMap(urwid.Divider("─", top=1, bottom=1), "date")
+        date_wgt = urwid.Columns([divider, ("flow", date_label), divider])
+        margin = ("fixed", 1, urwid.Text(" "))
+        super().__init__([margin, date_wgt, margin])
+
+
+class MessageItem(urwid.AttrMap):
+    """A single message item"""
+
+    def __init__(self, msg: Any, nickbg: str) -> None:
+        sender = msg.sender
+        sent_date = datetime.fromtimestamp(msg.timestamp)
+        if (
+            msg.show_padlock
+            or (sender.id <= SpecialContactId.LAST_SPECIAL and sender.id != SpecialContactId.SELF)
+            or msg.system_message_type == SystemMessageType.WEBXDC_INFO_MESSAGE
+        ):
+            timestamp = sent_date.strftime(" %H:%M ")
+            date_wgt = (len(timestamp), urwid.SelectableIcon(("encrypted", timestamp)))
+        else:
+            timestamp = sent_date.strftime("!%H:%M ")
+            date_wgt = (len(timestamp), urwid.SelectableIcon(("unencrypted", timestamp)))
+
+        header_wgt = get_sender_label(msg, nickbg)
+
+        lines = []
+        if msg.quote:
+            if msg.quote.kind == "WithMessage":
+                quote_sender = msg.quote.override_sender_name or msg.quote.author_display_name
+                quote_color = urwid.AttrSpec(msg.quote.author_display_color, nickbg)
+                lines.append((quote_color, f"│ {quote_sender}\n"))
+            else:
+                quote_color = "quote"
+            lines.append((quote_color, "│ "))
+            lines.append(("quote", f"{shorten_text(msg.quote.text, 150, placeholder='[…]')}\n"))
+        text = msg.text
+        if msg.file_name:
+            text = f"[{msg.file_name}]{' – ' if text else ''}{text}"
+        if msg.is_info:
+            lines.append(("system_msg", text))
+        else:
+            if sender.id == SpecialContactId.SELF:
+                lines.append(("self_msg", text))
+            else:
+                lines.append(text)
+        body_wgt = urwid.Text(lines or "")
+
+        cols = urwid.Columns([date_wgt, urwid.Pile([header_wgt, body_wgt])])
+        super().__init__(cols, None, focus_map="focused_item")
+
+
+class ConversationWidget(urwid.ListBox):
+    """Display a list of messages"""
+
+    def __init__(self, client: Client, nickbg: str) -> None:
+        self.client = client
+        self.nickbg = nickbg
+        self.chat: Optional[Tuple[int, int]] = None
+        super().__init__(LazyListWalker([], self._create_message_item))
+
+    def set_chat(self, chat: Optional[Tuple[int, int]]) -> None:
+        self.chat = chat
+        if chat:
+            self.client.rpc.marknoticed_chat(*chat)
+        self._update_conversation()
+
+    def messages_changed(self, _client: Client, accid: int, chatid: int, _msgid: int) -> None:
+        if self.chat and accid == self.chat[0] and chatid in (self.chat[1], 0):
+            self._update_conversation()
+
+    def _update_conversation(self) -> None:
+        self.body.clear_cache()
+        if self.chat:
+            items = self.client.rpc.get_message_list_items(*self.chat, False, True)
+            self.body[:] = [
+                (self.chat[0], item.kind, item.msg_id if item.kind == "message" else item.timestamp)
+                for item in items
+            ]
+            if items:
+                self.set_focus(len(items) - 1)
+        else:
+            self.body.clear()
+
+    def _create_message_item(self, item: Tuple[int, str, int]) -> urwid.Widget:
+        if item[1] == "message":
+            self.client.rpc.markseen_msgs(item[0], [item[2]])
+            return MessageItem(self.client.rpc.get_message(item[0], item[2]), self.nickbg)
+        return DayMarker(item[2])
+
+
+def get_sender_label(msg: Message, nickbg: str) -> urwid.Text:
+    name = shorten_text(msg.override_sender_name or msg.sender.display_name, 50)
+    components: list = [(urwid.AttrSpec(msg.sender.color, nickbg), name)]
+    if msg.state == MessageState.OUT_MDN_RCVD:
+        components.append(" ✓✓")
+    elif msg.state == MessageState.OUT_DELIVERED:
+        components.append(" ✓")
+    elif msg.state == MessageState.OUT_PENDING:
+        components.append(" →")
+    elif msg.state == MessageState.OUT_FAILED:
+        components.extend([" ", ("failed", " ! ")])
+    return urwid.Text(components)

arcanechat_tui/eventcenter.py

@@ -0,0 +1,45 @@
+"""Event center"""
+
+import urwid
+from deltachat2 import Client, CoreEvent, EventType
+
+CHATLIST_CHANGED = "chatlist_changed"
+CHAT_CHANGED = "chat_changed"
+MESSAGES_CHANGED = "msgs_changed"
+
+
+class EventCenter:
+    """Event center dispatching Delta Chat core events"""
+
+    signals = [CHATLIST_CHANGED, CHAT_CHANGED, MESSAGES_CHANGED]
+
+    def __init__(self) -> None:
+        urwid.register_signal(self.__class__, self.signals)
+
+    def process_core_event(self, client: Client, accid: int, event: CoreEvent) -> None:
+        if event.kind == EventType.CHAT_MODIFIED:
+            urwid.emit_signal(self, CHAT_CHANGED, client, accid, event.chat_id)
+            urwid.emit_signal(self, CHATLIST_CHANGED, client, accid)
+
+        elif event.kind == EventType.CONTACTS_CHANGED:
+            urwid.emit_signal(self, CHATLIST_CHANGED, client, accid)
+
+        elif event.kind == EventType.INCOMING_MSG:
+            urwid.emit_signal(self, MESSAGES_CHANGED, client, accid, event.chat_id, event.msg_id)
+            urwid.emit_signal(self, CHATLIST_CHANGED, client, accid)
+
+        elif event.kind == EventType.MSGS_CHANGED:
+            urwid.emit_signal(self, MESSAGES_CHANGED, client, accid, event.chat_id, event.msg_id)
+            urwid.emit_signal(self, CHATLIST_CHANGED, client, accid)
+
+        elif event.kind == EventType.MSGS_NOTICED:
+            urwid.emit_signal(self, CHATLIST_CHANGED, client, accid)
+
+        elif event.kind == EventType.MSG_DELIVERED:
+            urwid.emit_signal(self, MESSAGES_CHANGED, client, accid, event.chat_id, event.msg_id)
+
+        elif event.kind == EventType.MSG_FAILED:
+            urwid.emit_signal(self, MESSAGES_CHANGED, client, accid, event.chat_id, event.msg_id)
+
+        elif event.kind == EventType.MSG_READ:
+            urwid.emit_signal(self, MESSAGES_CHANGED, client, accid, event.chat_id, event.msg_id)

arcanechat_tui/lazylistwaker.py

@@ -0,0 +1,33 @@
+"""A ListWalker that creates the widgets dynamically as needed."""
+
+from functools import lru_cache
+from typing import Any, Callable, Iterable, NoReturn
+
+import urwid
+
+
+class LazyListWalker(urwid.SimpleListWalker):
+    """A ListWalker that creates the widgets dynamically as needed."""
+
+    def __init__(
+        self,
+        contents: Iterable,
+        widget_factory: Callable[[Any], urwid.Widget],
+        cache_size=1000,
+        wrap_around: bool = False,
+    ) -> None:
+        self.cache_size = cache_size
+        self._widget_factory = widget_factory
+        self.widget_factory = lru_cache(maxsize=cache_size)(widget_factory)
+        super().__init__(contents, wrap_around)
+
+    def clear_cache(self) -> None:
+        self.widget_factory = lru_cache(maxsize=self.cache_size)(self._widget_factory)
+
+    def __getitem__(self, position: int) -> urwid.Widget:
+        """return widget at position or raise an IndexError or KeyError"""
+        return self.widget_factory(super().__getitem__(position))
+
+    def set_modified_callback(self, callback: Callable[[], Any]) -> NoReturn:
+        """Ignore this, just copied from SimpleListWalker to avoid pylint warning"""
+        raise NotImplementedError('Use connect_signal(list_walker, "modified", ...) instead.')

arcanechat_tui/logger.py

@@ -0,0 +1,29 @@
+"""Logging to log files"""
+
+import logging
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+from . import APP_NAME
+
+
+def create_logger(level: str, folder: Path) -> logging.Logger:
+    logger = logging.Logger(APP_NAME)
+    logger.parent = None
+
+    if level == "disabled":
+        logger.disabled = True
+        return logger
+
+    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
+    log_path = folder / "logs"
+    log_path.mkdir(parents=True, exist_ok=True)
+    log_path /= "log.txt"
+
+    fhandler = RotatingFileHandler(log_path, backupCount=3, maxBytes=2000000)
+    fhandler.setLevel(level.upper())
+    fhandler.setFormatter(formatter)
+    logger.addHandler(fhandler)
+
+    return logger

arcanechat_tui/main.py

@@ -0,0 +1,64 @@
+"""Program's entry point"""
+
+import logging
+import subprocess
+
+from deltachat2 import Client, CoreEvent, EventType, IOTransport, Rpc, events
+
+from .application import Application
+from .cli import Cli
+from .logger import create_logger
+from .util import get_account
+
+FG_COLOR = "white"
+BG_COLOR = "g11"
+dtheme = {
+    "background": ["", "", "", FG_COLOR, BG_COLOR],
+    "status_bar": ["", "", "", "white", "g23"],
+    "focused_item": ["", "", "", "white", "g23"],
+    "separator": ["", "", "", "g15", "g15"],
+    "date": ["", "", "", "#6f0", BG_COLOR],
+    "encrypted": ["", "", "", "dark gray", BG_COLOR],
+    "unencrypted": ["", "", "", "dark red", BG_COLOR],
+    "failed": ["", "", "", "white", "dark red"],
+    "selected_chat": ["", "", "", "black", "light blue"],
+    "unread_badge": ["", "", "", "#000", "#6f0"],
+    "unread_badge_muted": ["", "", "", "#000", "dark gray"],
+    "reversed": ["", "", "", BG_COLOR, FG_COLOR],
+    "quote": ["", "", "", "dark gray", BG_COLOR],
+    "mention": ["", "", "", "bold, light red", BG_COLOR],
+    "system_msg": ["", "", "", "dark gray", BG_COLOR],
+    "self_msg": ["", "", "", "dark green", BG_COLOR],
+}
+dkeymap = {
+    "quit": "q",
+    "send_msg": "enter",
+    "insert_new_line": "meta enter",
+    "next_chat": "meta up",
+    "prev_chat": "meta down",
+}
+hooks = events.HookCollection()
+
+
+@hooks.on(events.RawEvent)
+def log_event(client: Client, accid: int, event: CoreEvent) -> None:
+    if event.kind == EventType.INFO:
+        client.logger.debug("[acc=%s] %s", accid, event.msg)
+    elif event.kind == EventType.WARNING:
+        client.logger.warning("[acc=%s] %s", accid, event.msg)
+    elif event.kind == EventType.ERROR:
+        client.logger.error("[acc=%s] %s", accid, event.msg)
+
+
+def main() -> None:
+    args = Cli().parse_args()
+    args.program_folder.mkdir(parents=True, exist_ok=True)
+    accounts_dir = args.program_folder / "accounts"
+    logging.getLogger("deltachat2.IOTransport").disabled = True
+    with IOTransport(accounts_dir=accounts_dir, stderr=subprocess.DEVNULL) as trans:
+        client = Client(Rpc(trans), hooks, create_logger(args.log, args.program_folder))
+        if "cmd" in args:
+            args.cmd(client, args)
+        else:
+            accid = get_account(client.rpc, args.account)
+            Application(client, keymap=dkeymap, theme=dtheme).run(accid)

arcanechat_tui/util.py

@@ -0,0 +1,86 @@
+"""Utilities"""
+
+from pathlib import Path
+from typing import Any
+
+from deltachat2 import ChatType, Rpc
+
+
+def shorten_text(text: str, width: int, placeholder: str = "…") -> str:
+    text = " ".join(text.split())
+    if len(text) > width:
+        width -= len(placeholder)
+        assert width > 0, "placeholder can't be bigger than width"
+        text = text[:width].strip() + placeholder
+    return text
+
+
+def get_subtitle(rpc: Rpc, accid: int, chat: Any) -> str:
+    if chat.is_self_talk:
+        return "Messages I sent to myself"
+    if chat.is_device_chat:
+        return "Locally generated messages"
+    if chat.chat_type == ChatType.MAILINGLIST:
+        return "Mailing List"
+
+    members = rpc.get_chat_contacts(accid, chat.id)
+    if chat.chat_type == ChatType.SINGLE:
+        subtitle = rpc.get_contact(accid, members[0]).address
+    elif chat.chat_type == ChatType.BROADCAST:
+        count = len(members)
+        subtitle = "1 recipient" if count == 1 else f"{count} recipients"
+    else:
+        count = len(members)
+        subtitle = "1 member" if count == 1 else f"{count} members"
+
+    return subtitle
+
+
+def abspath(path: str) -> Path:
+    try:
+        return Path(path).expanduser().absolute()
+    except RuntimeError:
+        return Path(path).absolute()
+
+
+def parse_docstring(txt) -> tuple:
+    """parse docstring, returning a tuple with short and long description"""
+    description = txt
+    i = txt.find(".")
+    if i == -1:
+        help_ = txt
+    else:
+        help_ = txt[: i + 1]
+    return help_, description
+
+
+def get_or_create_account(rpc: Rpc, addr: str) -> int:
+    """Get account for address, if no account exists create a new one."""
+    accid = get_account(rpc, addr)
+    if not accid:
+        accid = rpc.add_account()
+        rpc.set_config(accid, "addr", addr)
+    return accid
+
+
+def get_account(rpc: Rpc, addr: str) -> int:
+    """Get account id for address.
+    If no account exists with the given address, zero is returned.
+    """
+    if not addr:
+        return 0
+
+    try:
+        return int(addr)
+    except ValueError:
+        for accid in rpc.get_all_account_ids():
+            if addr == get_address(rpc, accid):
+                return accid
+
+    return 0
+
+
+def get_address(rpc: Rpc, accid: int) -> str:
+    if rpc.is_configured(accid):
+        return rpc.get_config(accid, "configured_addr")
+    return rpc.get_config(accid, "addr")

arcanechat_tui/welcome_widget.py

@@ -0,0 +1,10 @@
+"""Welcome screen widget displayed when no chat is selected"""
+
+import urwid
+
+
+class WelcomeWidget(urwid.Filler):
+    """Welcome screen widget displayed when no chat is selected"""
+
+    def __init__(self) -> None:
+        super().__init__(urwid.Text("(No chat selected)", align="center"))