arcanechat-tui 0.11.0__py3-none-any.whl

arcanechat_tui/__init__.py

@@ -0,0 +1,3 @@
+"""Cursed Delta, a TUI Delta Chat client for the command line"""
+
+APP_NAME = "CursedDelta"

arcanechat_tui/__main__.py

@@ -0,0 +1,5 @@
+"""Support for python module excecution"""
+
+from .main import main
+
+main()

arcanechat_tui/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.11.0'
+__version_tuple__ = version_tuple = (0, 11, 0)

arcanechat_tui/application.py

@@ -0,0 +1,165 @@
+"""Main UI program"""
+
+import sys
+from threading import Thread
+from typing import Optional, Tuple
+
+import urwid
+from deltachat2 import Client
+
+from .cards_widget import CardsWidget
+from .chatlist import CHAT_SELECTED, ChatListWidget
+from .composer import SENDING_MSG_FAILED, ComposerWidget
+from .container import Container
+from .conversation import ConversationWidget
+from .eventcenter import CHATLIST_CHANGED, MESSAGES_CHANGED, EventCenter
+from .util import shorten_text
+from .welcome_widget import WelcomeWidget
+
+
+class Application:
+    """Main application UI"""
+
+    def __init__(self, client: Client, keymap: dict, theme: dict) -> None:
+        self.client = client
+        self.keymap = keymap
+        self.accid: Optional[int] = None
+        eventcenter = EventCenter()
+
+        self.chatlist = ChatListWidget(client)
+        urwid.connect_signal(eventcenter, CHATLIST_CHANGED, self.chatlist.chatlist_changed)
+        chatlist_cont = Container(self.chatlist, self._chatlist_keypress)
+
+        conversation = ConversationWidget(client, theme["background"][-1])
+        urwid.connect_signal(self.chatlist, CHAT_SELECTED, conversation.set_chat)
+        urwid.connect_signal(eventcenter, MESSAGES_CHANGED, conversation.messages_changed)
+        conversation_cont = Container(conversation, self._conversation_keypress)
+
+        composer = ComposerWidget(client, keymap)
+        urwid.connect_signal(self.chatlist, CHAT_SELECTED, composer.set_chat)
+        composer_cont = Container(composer, self._composer_keypress)
+
+        self.cards = CardsWidget()
+        self.cards.add("welcome", WelcomeWidget())
+        self.cards.add("conversation", conversation_cont)
+        self.cards.show("welcome")
+
+        self.right_side = urwid.Pile([self.cards, (urwid.PACK, composer_cont)])
+
+        vsep = urwid.AttrMap(urwid.Filler(urwid.Columns([])), "separator")
+
+        # layout root
+        self.main_columns = urwid.Columns(
+            [("weight", 1, chatlist_cont), (1, vsep), ("weight", 4, self.right_side)]
+        )
+        self.frame = urwid.Frame(self.main_columns)
+
+        self.loop = urwid.MainLoop(
+            urwid.AttrMap(self.frame, "background"),
+            [(key, *value) for key, value in theme.items()],
+            unhandled_input=self._unhandled_keypress,
+        )
+        self.loop.screen.set_terminal_properties(colors=256)
+
+        urwid.connect_signal(self.chatlist, CHAT_SELECTED, self.chat_selected)
+        urwid.connect_signal(composer, SENDING_MSG_FAILED, self.sending_msg_failed)
+        urwid.connect_signal(eventcenter, CHATLIST_CHANGED, self.chatlist_changed)
+        urwid.connect_signal(eventcenter, MESSAGES_CHANGED, self.messages_changed)
+        client.add_hook(eventcenter.process_core_event)
+
+    def _print_title(self) -> None:
+        badge = 0
+        for acc in self.client.rpc.get_all_account_ids():
+            badge += len(self.client.rpc.get_fresh_msgs(acc))
+        name = self.client.rpc.get_config(self.accid, "displayname")
+        if not name:
+            name = self.client.rpc.get_config(self.accid, "configured_addr")
+        name = shorten_text(name, 30)
+        if badge > 0:
+            text = f"\x1b]2;({badge if badge < 999 else '+999'}) {name}\x07"
+        else:
+            text = f"\x1b]2;{name}\x07"
+        sys.stdout.write(text)
+
+    def exit(self) -> None:
+        sys.stdout.write("\x1b]2;\x07")
+        raise urwid.ExitMainLoop
+
+    def chat_selected(self, chat: Optional[Tuple[int, int]]) -> None:
+        if chat:
+            self.cards.show("conversation")
+            # focus composer
+            self.main_columns.focus_position = 2
+            self.right_side.focus_position = 1
+        else:
+            self.cards.show("welcome")
+            # focus chatlist
+            self.main_columns.focus_position = 0
+
+    def messages_changed(self, _client: Client, accid: int, chatid: int, _msgid: int) -> None:
+        chat = self.chatlist.selected_chat
+        if accid == self.accid and chat and chatid in (chat[1], 0):
+            self.loop.draw_screen()
+
+    def chatlist_changed(self, _client: Client, accid: int) -> None:
+        self._print_title()
+        if accid == self.accid:
+            self.loop.draw_screen()
+
+    def sending_msg_failed(self, error: str) -> None:
+        self.toast(urwid.AttrMap(urwid.Text([" Error: ", error]), "failed"), 5)
+
+    def toast(self, element: urwid.Widget, duration: int) -> None:
+        def reset_footer(*_) -> None:
+            if self.frame.footer == element:
+                self.frame.footer = None
+
+        self.frame.footer = element
+        self.loop.set_alarm_in(duration, reset_footer)
+
+    def _unhandled_keypress(self, key: str) -> None:
+        if key == self.keymap["quit"]:
+            self.exit()
+
+    def _chatlist_keypress(self, _size: list, key: str) -> Optional[str]:
+        if key in ("right", "tab"):
+            # give focus to the composer area
+            self.main_columns.focus_position = 2
+            self.right_side.focus_position = 1
+            return None
+        return key
+
+    def _conversation_keypress(self, _size: list, key: str) -> Optional[str]:
+        if key in ("tab", "esc"):
+            # give focus to the composer area
+            self.right_side.focus_position = 1
+            return None
+        return key
+
+    def _composer_keypress(self, _size: list, key: str) -> Optional[str]:
+        if key == "esc":
+            self.chatlist.select_chat(None)
+            return None
+        return key
+
+    def run(self, accid: int = 0) -> None:
+        rpc = self.client.rpc
+        self.accid = accid or self.client.rpc.get_selected_account_id()
+        if not self.accid:
+            accounts = [rpc.is_configured(accid) for accid in rpc.get_all_account_ids()]
+            if accounts:
+                self.accid = accounts[0]
+            else:
+                print("Error: No account configured yet")
+                sys.exit(1)
+        elif not rpc.is_configured(self.accid):
+            print("Error: Account configured yet")
+            sys.exit(1)
+
+        self.chatlist.set_account(self.accid)
+        self._print_title()
+        Thread(target=self.client.run_forever, daemon=True).start()
+        try:
+            self.loop.run()
+        except KeyboardInterrupt:
+            pass

arcanechat_tui/cards_widget.py

@@ -0,0 +1,35 @@
+"""Cards layout widget, a stack of widgets, only one is visible at a time"""
+
+from typing import Dict
+
+import urwid
+
+EMPTY = urwid.Widget()
+
+
+class CardsWidget(urwid.WidgetPlaceholder):
+    """Cards layout widget, a stack of widgets, only one of them is visible at a time"""
+
+    original_widget: urwid.Widget
+
+    def __init__(self) -> None:
+        super().__init__(EMPTY)
+        self.cards: Dict[str, urwid.Widget] = {}
+
+    def add(self, name: str, widget: urwid.Widget) -> None:
+        """Add a new widget to the stack.
+
+        The name must be an unique string ID to identify the item.
+        """
+        self.cards[name] = widget
+
+    def remove(self, name: str) -> urwid.Widget:
+        """Remove an item from the stack corresponding to the given name."""
+        widget = self.cards.pop(name)
+        if widget is self.original_widget:
+            self.original_widget = EMPTY
+        return widget
+
+    def show(self, name: str) -> None:
+        """Show the widget corresponding to the given name."""
+        self.original_widget = self.cards[name]

arcanechat_tui/chatlist.py

@@ -0,0 +1,104 @@
+"""Chat list widget"""
+
+from typing import Any, Callable, Optional, Tuple
+
+import urwid
+from deltachat2 import ChatlistFlag, Client
+
+from .lazylistwaker import LazyListWalker
+from .util import shorten_text
+
+CHAT_SELECTED = "chat_selected"
+
+
+class ChatListItem(urwid.Button):
+    """A single chatlist item"""
+
+    def __init__(
+        self,
+        accid: int,
+        item: Any,
+        selected: bool,
+        callback: Callable[["ChatListItem"], None],
+    ) -> None:
+        super().__init__("", callback)
+        self.accid = accid
+        self.id = item.id
+        elements: list = []
+
+        if item.is_self_talk:
+            color = "#0af"
+            icon = "*"
+        elif item.is_device_talk:
+            color = "#888"
+            icon = "i"
+        else:
+            color = item.color
+            icon = "@" if item.dm_chat_contact else "#"
+        elements.append((urwid.AttrSpec("#fff", color), f" {icon} "))
+
+        if item.is_pinned:
+            elements.append("*")
+        else:
+            elements.append(" ")
+
+        name = shorten_text(item.name, 40)
+        elements.append(("selected_chat", name) if selected else name)
+
+        if item.fresh_message_counter > 0:
+            elements.append(" ")
+            style = "unread_badge_muted" if item.is_muted else "unread_badge"
+            elements.append((style, f"({item.fresh_message_counter})"))
+
+        self._w = urwid.AttrMap(urwid.SelectableIcon(elements, 3), None, focus_map="focused_item")
+
+
+class ChatListWidget(urwid.ListBox):
+    """Display a list of chats"""
+
+    signals = [CHAT_SELECTED]
+
+    def __init__(self, client: Client) -> None:
+        self.client = client
+        self.accid: Optional[int] = None
+        self.selected_chat: Optional[Tuple[int, int]] = None
+        super().__init__(LazyListWalker([], self._create_chatlist_item))
+
+    def set_account(self, accid: Optional[int]) -> None:
+        self.accid = accid
+        if self.selected_chat and accid != self.selected_chat[0]:
+            self._select_chat(None)
+        self.chatlist_changed(self.client, accid)
+
+    def select_chat(self, chat: Optional[Tuple[int, int]]) -> None:
+        self._select_chat(chat)
+        self.chatlist_changed(self.client, self.accid)
+
+    def chatlist_changed(self, client: Client, accid: Optional[int]) -> None:
+        if not self.accid:
+            self.body.clear_cache()
+            self.body.clear()
+        elif accid == self.accid:
+            entries = client.rpc.get_chatlist_entries(accid, ChatlistFlag.NO_SPECIALS, None, None)
+            item = self.focus
+            self.body.clear_cache()
+            self.body[:] = [(accid, chatid) for chatid in entries]
+            try:
+                index = max(entries.index(item.id), 0) if item else 0
+            except ValueError:
+                pass
+            else:
+                if entries:
+                    self.set_focus(index)
+
+    def _create_chatlist_item(self, chat: Tuple[int, int]) -> urwid.Widget:
+        item = self.client.rpc.get_chatlist_items_by_entries(chat[0], [chat[1]])[str(chat[1])]
+        return ChatListItem(chat[0], item, self.selected_chat == chat, self._on_item_clicked)
+
+    def _on_item_clicked(self, item: ChatListItem) -> None:
+        self._select_chat((item.accid, item.id))
+        self.chatlist_changed(self.client, self.accid)  # so the selected chat widget is updated
+
+    def _select_chat(self, chat: Optional[Tuple[int, int]]) -> None:
+        self.selected_chat = chat
+        urwid.emit_signal(self, CHAT_SELECTED, self.selected_chat)

arcanechat_tui/cli.py

@@ -0,0 +1,149 @@
+"""Command line arguments parsing"""
+
+import sys
+from argparse import ArgumentParser, Namespace
+from typing import Callable
+
+from appdirs import user_config_dir
+from deltachat2 import Client, JsonRpcError
+
+from . import APP_NAME
+from ._version import __version__
+from .util import abspath, get_account, get_or_create_account, parse_docstring
+
+
+class Cli:
+    """Command line argument parser"""
+
+    def __init__(self) -> None:
+        self._parser = ArgumentParser()
+        self._subcommands = self._parser.add_subparsers(title="subcommands")
+
+        self._parser.add_argument("-v", "--version", action="version", version=__version__)
+
+        self._parser.add_argument(
+            "--program-folder",
+            "-f",
+            help="program configuration folder (default: %(default)s)",
+            metavar="PATH",
+            default=user_config_dir(APP_NAME),
+            type=abspath,
+        )
+
+        self._parser.add_argument(
+            "--account",
+            "-a",
+            help="operate only over the given account when running any subcommand",
+            metavar="ADDR",
+        )
+
+        self._parser.add_argument(
+            "--log",
+            help=(
+                "set the severity level of what should be saved in the log file"
+                " (default: %(default)s)"
+            ),
+            choices=["debug", "info", "warning", "error", "disabled"],
+            default="warning",
+            type=str.lower,
+        )
+
+        init_parser = self.add_subcommand(init_cmd, name="init")
+        init_parser.add_argument("addr", help="your e-mail address")
+        init_parser.add_argument("password", help="your password")
+
+        import_parser = self.add_subcommand(import_cmd, name="import")
+        import_parser.add_argument("path", help="path to the backup file to import")
+
+        config_parser = self.add_subcommand(config_cmd, name="config")
+        config_parser.add_argument("option", help="option name", nargs="?")
+        config_parser.add_argument("value", help="option value to set", nargs="?")
+
+    def add_subcommand(
+        self,
+        func: Callable[["Cli", Namespace], None],
+        **kwargs,
+    ) -> ArgumentParser:
+        """Add a subcommand to the CLI."""
+        if not kwargs.get("name"):
+            kwargs["name"] = func.__name__
+        if not kwargs.get("help") and not kwargs.get("description"):
+            kwargs["help"], kwargs["description"] = parse_docstring(func.__doc__)
+        subparser = self._subcommands.add_parser(**kwargs)
+        subparser.set_defaults(cmd=func)
+        return subparser
+
+    def parse_args(self) -> Namespace:
+        """Parse command line arguments"""
+        return self._parser.parse_args()
+
+
+def init_cmd(client: Client, args: Namespace) -> None:
+    """initialize an account"""
+    if args.account:
+        accid = get_account(client.rpc, args.account)
+        if not accid or accid not in client.rpc.get_all_account_ids():
+            print(f"Error: unknown account: {args.account!r}")
+            sys.exit(1)
+    else:
+        accid = get_or_create_account(client.rpc, args.addr)
+
+    try:
+        client.configure(accid, email=args.addr, password=args.password)
+        print("Account configured successfully.")
+    except JsonRpcError as err:
+        print("ERROR: Configuration failed:", err)
+        sys.exit(1)
+
+
+def import_cmd(client: Client, args: Namespace) -> None:
+    """import account from backup file"""
+    if args.account:
+        print("Error: -a/--account can't be used with this subcommand")
+        sys.exit(1)
+
+    try:
+        client.rpc.import_backup(client.rpc.add_account(), args.path, None)
+        print("Backup imported successfully.")
+    except JsonRpcError as err:
+        print("ERROR: Failed to import backup:", err)
+        sys.exit(1)
+
+
+def config_cmd(client: Client, args: Namespace) -> None:
+    """set or get account configuration values"""
+    accounts = client.rpc.get_all_account_ids()
+    if not args.account and len(accounts) == 1:
+        args.account = accounts[0]
+
+    if args.account:
+        accid = get_account(client.rpc, args.account)
+        if not accid or accid not in accounts:
+            print(f"Error: unknown account: {args.account!r}")
+            sys.exit(1)
+
+        keys = (client.rpc.get_config(accid, "sys.config_keys") or "").split()
+        if args.option and not args.option.startswith("ui.") and args.option not in keys:
+            print(f"Error: unknown configuration option: {args.option}")
+            sys.exit(1)
+
+        if args.value:
+            client.rpc.set_config(accid, args.option, args.value)
+
+        if args.option:
+            try:
+                value = client.rpc.get_config(accid, args.option)
+                print(f"{args.option}={value!r}")
+            except JsonRpcError:
+                print(f"Error: unknown configuration option: {args.option}")
+                sys.exit(1)
+        else:
+            for key in keys:
+                value = client.rpc.get_config(accid, key)
+                print(f"{key}={value!r}")
+    else:
+        print(
+            "Error: you must use --account option to set what account to set/get"
+            " configuration values"
+        )
+        sys.exit(1)

arcanechat_tui/composer.py

@@ -0,0 +1,86 @@
+"""Composer area widget"""
+
+from typing import Dict, Optional, Tuple
+
+import urwid
+import urwid_readline
+from deltachat2 import Client, JsonRpcError, MsgData
+
+from ._version import __version__
+from .util import get_subtitle, shorten_text
+
+SENDING_MSG_FAILED = "sending_msg_failed"
+
+
+class ReadlineEdit2(urwid_readline.ReadlineEdit):
+    """Edit widget"""
+
+    def __init__(self, insert_new_line_key: str) -> None:
+        super().__init__(multiline=True)
+        del self.keymap["enter"]
+        self.keymap[insert_new_line_key] = self.insert_new_line
+
+    def previous_line(self):
+        """Patch bug: https://github.com/rr-/urwid_readline/issues/24"""
+        x, y = self.get_cursor_coords(self.size)
+        return self.move_cursor_to_coords(self.size, x, y - 1)
+
+
+class ComposerWidget(urwid.Filler):
+    """Composer area and chat status bar"""
+
+    signals = [SENDING_MSG_FAILED]
+
+    def __init__(self, client: Client, keymap: Dict[str, str]) -> None:
+        self.client = client
+        self.keymap = keymap
+        self.chat: Optional[Tuple[int, int]] = None
+        self.status_bar = urwid.Text(("status_bar", ""), align="left")
+        self.edit_widget = ReadlineEdit2(keymap["insert_new_line"])
+        prompt = urwid.Columns([(urwid.PACK, urwid.Text("> ")), self.edit_widget])
+        super().__init__(urwid.Pile([urwid.AttrMap(self.status_bar, "status_bar"), prompt]))
+        self._update_status_bar(None)
+
+    def set_chat(self, chat: Optional[Tuple[int, int]]) -> None:
+        self.chat = chat
+        self.edit_widget.set_edit_text("")
+        self.edit_widget.set_edit_pos(0)
+        self._update_status_bar(chat)
+
+    def _send_message(self, text) -> None:
+        accid, chatid = self.chat or (0, 0)
+        if accid:
+            chat = self.client.rpc.get_basic_chat_info(accid, chatid)
+            if chat.is_contact_request or chat.is_protection_broken:
+                # accept contact requests automatically on sending
+                self.client.rpc.accept_chat(accid, chatid)
+            try:
+                self.client.rpc.send_msg(accid, chatid, MsgData(text=text))
+            except JsonRpcError:
+                errmsg = "Message could not be sent, are you a member of the chat?"
+                urwid.emit_signal(self, SENDING_MSG_FAILED, errmsg)
+        else:
+            urwid.emit_signal(self, SENDING_MSG_FAILED, "No chat selected")
+
+    def _update_status_bar(self, chat: Optional[Tuple[int, int]]) -> None:
+        if chat:
+            info = self.client.rpc.get_basic_chat_info(*chat)
+            verified = "✓ " if info.is_protected or info.is_device_chat else ""
+            muted = " (muted)" if info.is_muted else ""
+            name = shorten_text(info.name, 40)
+
+            subtitle = shorten_text(get_subtitle(self.client.rpc, chat[0], info), 40)
+            text = f" {verified}[ {name} ]{muted} -- {subtitle}"
+        else:
+            text = f" Cursed Delta {__version__}"
+
+        self.status_bar.set_text(text)
+
+    def keypress(self, size: list, key: str) -> Optional[str]:
+        if key == self.keymap["send_msg"]:
+            text = self.edit_widget.get_edit_text().strip()
+            if text:
+                self.edit_widget.set_edit_text("")
+                self._send_message(text)
+            return None
+        return super().keypress(size, key)

arcanechat_tui/container.py

@@ -0,0 +1,31 @@
+"""Widget container that handles key presses in the contained widget."""
+
+from typing import Callable, Optional
+
+import urwid
+
+
+class Container(urwid.WidgetPlaceholder):
+    """Widget container that handles key presses in the contained widget."""
+
+    def __init__(
+        self,
+        widget: urwid.Widget,
+        callback: Callable[[list, str], Optional[str]],
+        unhandled_only: bool = True,
+    ) -> None:
+        """
+        :param widget: the contained widget
+        :param callback: the callback to call on key presses unhandled by the contained widget
+        :param unhandled_only: if set to False call callback first and if it didn't handle
+                               the key press then pass it to the contained widget. If set to True
+                               only call callback on unhandled key presses
+        """
+        self._callback = callback
+        self._unhandled_only = unhandled_only
+        super().__init__(widget)
+
+    def keypress(self, size: list, key: str) -> Optional[str]:
+        if self._unhandled_only:
+            return super().keypress(size, key) and self._callback(size, key)
+        return self._callback(size, key) and super().keypress(size, key)