deltabot-cli 0.2.0__tar.gz → 1.0.0__tar.gz

{deltabot-cli-0.2.0 → deltabot-cli-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deltabot-cli
-Version: 0.2.0
+Version: 1.0.0
 Summary: Library to speedup Delta Chat bot development
 Author-email: adbenitez <adbenitez@hispanilandia.net>
 Keywords: deltachat,bot,deltabot-cli
@@ -10,7 +10,7 @@ Classifier: Intended Audience :: Developers
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: deltachat-rpc-client>=1.127.0
+Requires-Dist: deltachat-rpc-server>=1.133.2
 Requires-Dist: appdirs>=1.4.4
 Requires-Dist: rich>=12.6.0
 Requires-Dist: qrcode>=7.4.2
@@ -21,8 +21,6 @@ Requires-Dist: isort; extra == "dev"
 Requires-Dist: pylint; extra == "dev"
 Requires-Dist: pylama; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
-Provides-Extra: server
-Requires-Dist: deltachat-rpc-server>=1.127.0; extra == "server"
 
 # deltabot-cli for Python
 
@@ -32,21 +30,15 @@ Requires-Dist: deltachat-rpc-server>=1.127.0; extra == "server"
 
 Library to speedup Delta Chat bot development.
 
-With this library you can focus on writing your event/message processing logic and let us handle the repetitive
-process of creating the bot CLI.
+With this library you can focus on writing your event/message processing logic and let us handle the
+repetitive process of creating the bot CLI.
 
 ## Install
 
 ```sh
-pip install deltabot-cli-py
+pip install deltabot-cli
 ```
 
-### Installing deltachat-rpc-server
-
-This package depends on a standalone Delta Chat RPC server `deltachat-rpc-server` program.
-To install it check:
-https://github.com/deltachat/deltachat-core-rust/tree/master/deltachat-rpc-server
-
 ## Usage
 
 Example echo-bot written with deltabot-cli:
@@ -57,16 +49,14 @@ from deltabot_cli import BotCli, events
 
 cli = BotCli("echobot")
 
-
 @cli.on(events.RawEvent)
 def log_event(event):
     logging.info(event)
 
-
 @cli.on(events.NewMessage)
 def echo(event):
-    event.chat.send_text(event.text)
-
+    msg = event.msg
+    event.rpc.misc_send_text_message(event.accid, msg.chat_id, msg.text)
 
 if __name__ == "__main__":
     cli.start()
@@ -76,5 +66,3 @@ If you run the above script you will have a bot CLI, that allows to configure an
 A progress bar is displayed while the bot is configuring, and logs are pretty-printed.
 
 For more examples check the [examples](https://github.com/deltachat-bot/deltabot-cli-py/tree/master/examples) folder.
-
-**Note:** deltabot-cli uses [deltachat-rpc-client](https://github.com/deltachat/deltachat-core-rust/tree/master/deltachat-rpc-client) library, check its documentation and examples to better understand how to use deltabot-cli.

{deltabot-cli-0.2.0 → deltabot-cli-1.0.0}/README.md

@@ -6,21 +6,15 @@
 
 Library to speedup Delta Chat bot development.
 
-With this library you can focus on writing your event/message processing logic and let us handle the repetitive
-process of creating the bot CLI.
+With this library you can focus on writing your event/message processing logic and let us handle the
+repetitive process of creating the bot CLI.
 
 ## Install
 
 ```sh
-pip install deltabot-cli-py
+pip install deltabot-cli
 ```
 
-### Installing deltachat-rpc-server
-
-This package depends on a standalone Delta Chat RPC server `deltachat-rpc-server` program.
-To install it check:
-https://github.com/deltachat/deltachat-core-rust/tree/master/deltachat-rpc-server
-
 ## Usage
 
 Example echo-bot written with deltabot-cli:
@@ -31,16 +25,14 @@ from deltabot_cli import BotCli, events
 
 cli = BotCli("echobot")
 
-
 @cli.on(events.RawEvent)
 def log_event(event):
     logging.info(event)
 
-
 @cli.on(events.NewMessage)
 def echo(event):
-    event.chat.send_text(event.text)
-
+    msg = event.msg
+    event.rpc.misc_send_text_message(event.accid, msg.chat_id, msg.text)
 
 if __name__ == "__main__":
     cli.start()
@@ -50,5 +42,3 @@ If you run the above script you will have a bot CLI, that allows to configure an
 A progress bar is displayed while the bot is configuring, and logs are pretty-printed.
 
 For more examples check the [examples](https://github.com/deltachat-bot/deltabot-cli-py/tree/master/examples) folder.
-
-**Note:** deltabot-cli uses [deltachat-rpc-client](https://github.com/deltachat/deltachat-core-rust/tree/master/deltachat-rpc-client) library, check its documentation and examples to better understand how to use deltabot-cli.

deltabot-cli-1.0.0/deltabot_cli/__init__.py

@@ -0,0 +1,8 @@
+"""Library to help with Delta Chat bot development"""
+
+# pylama:ignore=W0611,W0401
+from ._utils import AttrDict
+from .cli import BotCli
+from .client import Bot
+from .const import *
+from .rpc import JsonRpcError, Rpc

deltabot-cli-1.0.0/deltabot_cli/_utils.py

@@ -0,0 +1,213 @@
+"""Utilities"""
+
+import argparse
+import re
+import sys
+from threading import Thread
+from typing import TYPE_CHECKING, Callable, Iterable, Optional, Tuple, Type, Union
+
+from rich.progress import track
+
+if TYPE_CHECKING:
+    from .client import Client
+    from .events import EventFilter
+
+
+class ConfigProgressBar:
+    """Display a configuration Progress Bar."""
+
+    def __init__(self) -> None:
+        self.progress = 0
+        self.total = 1000
+        self.tracker = track(range(self.total), description="Configuring...")
+
+    def set_progress(self, progress: int) -> None:
+        """Set the progress bar progress."""
+        if progress == 0:
+            self.progress = -1
+        else:
+            progress = progress - self.progress
+            for _ in zip(self.tracker, range(progress)):
+                pass
+            self.progress += progress
+
+    def close(self) -> None:
+        """Finish the progress bar"""
+        self.tracker.close()
+
+
+class AttrDict(dict):
+    """Dictionary that allows accessing values using the "dot notation" as attributes."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(
+            {
+                _camel_to_snake(key): to_attrdict(value)
+                for key, value in dict(*args, **kwargs).items()
+            }
+        )
+
+    def __getattr__(self, attr):
+        if attr in self:
+            return self[attr]
+        raise AttributeError("Attribute not found: " + str(attr))
+
+    def __setattr__(self, attr, val):
+        if attr in self:
+            raise AttributeError("Attribute-style access is read only")
+        super().__setattr__(attr, val)
+
+
+def _camel_to_snake(name: str) -> str:
+    name = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
+    name = re.sub("__([A-Z])", r"_\1", name)
+    name = re.sub("([a-z0-9])([A-Z])", r"\1_\2", name)
+    return name.lower()
+
+
+def to_attrdict(obj):
+    if isinstance(obj, AttrDict):
+        return obj
+    if isinstance(obj, dict):
+        return AttrDict(obj)
+    if isinstance(obj, list):
+        return [to_attrdict(elem) for elem in obj]
+    return obj
+
+
+def run_client_cli(
+    hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
+    argv: Optional[list] = None,
+    **kwargs,
+) -> None:
+    """Run a simple command line app, using the given hooks.
+
+    Extra keyword arguments are passed to the internal Rpc object.
+    """
+    from .client import Client  # noqa
+
+    _run_cli(Client, hooks, argv, **kwargs)
+
+
+def run_bot_cli(
+    hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
+    argv: Optional[list] = None,
+    **kwargs,
+) -> None:
+    """Run a simple bot command line using the given hooks.
+
+    Extra keyword arguments are passed to the internal Rpc object.
+    """
+    from .client import Bot  # noqa
+
+    _run_cli(Bot, hooks, argv, **kwargs)
+
+
+def _run_cli(
+    client_type: Type["Client"],
+    hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
+    argv: Optional[list] = None,
+    **kwargs,
+) -> None:
+    from .rpc import Rpc  # noqa
+
+    if argv is None:
+        argv = sys.argv
+
+    parser = argparse.ArgumentParser(prog=argv[0] if argv else None)
+    parser.add_argument(
+        "accounts_dir",
+        help="accounts folder (default: current working directory)",
+        nargs="?",
+    )
+    parser.add_argument("--email", action="store", help="email address")
+    parser.add_argument("--password", action="store", help="password")
+    args = parser.parse_args(argv[1:])
+
+    with Rpc(accounts_dir=args.accounts_dir, **kwargs) as rpc:
+        core_version = rpc.get_system_info().deltachat_core_version
+        accounts = rpc.get_all_account_ids()
+        accid = accounts[0] if accounts else rpc.add_account()
+
+        client = client_type(rpc, hooks)
+        client.logger.debug("Running deltachat core %s", core_version)
+        if not rpc.is_configured(accid):
+            assert args.email, "Account is not configured and email must be provided"
+            assert args.password, "Account is not configured and password must be provided"
+            configure_thread = Thread(
+                target=client.configure, args=(accid, args.email, args.password)
+            )
+            configure_thread.start()
+        client.run_forever()
+
+
+def extract_addr(text: str) -> str:
+    """extract email address from the given text."""
+    match = re.match(r".*\((.+@.+)\)", text)
+    if match:
+        text = match.group(1)
+    text = text.rstrip(".")
+    return text.strip()
+
+
+def parse_system_image_changed(text: str) -> Optional[Tuple[str, bool]]:
+    """return image changed/deleted info from parsing the given system message text."""
+    text = text.lower()
+    match = re.match(r"group image (changed|deleted) by (.+).", text)
+    if match:
+        action, actor = match.groups()
+        return (extract_addr(actor), action == "deleted")
+    return None
+
+
+def parse_system_title_changed(text: str) -> Optional[Tuple[str, str]]:
+    text = text.lower()
+    match = re.match(r'group name changed from "(.+)" to ".+" by (.+).', text)
+    if match:
+        old_title, actor = match.groups()
+        return (extract_addr(actor), old_title)
+    return None
+
+
+def parse_system_add_remove(text: str) -> Optional[Tuple[str, str, str]]:
+    """return add/remove info from parsing the given system message text.
+
+    returns a (action, affected, actor) tuple.
+    """
+    # You removed member a@b.
+    # You added member a@b.
+    # Member Me (x@y) removed by a@b.
+    # Member x@y added by a@b
+    # Member With space (tmp1@x.org) removed by tmp2@x.org.
+    # Member With space (tmp1@x.org) removed by Another member (tmp2@x.org).",
+    # Group left by some one (tmp1@x.org).
+    # Group left by tmp1@x.org.
+    text = text.lower()
+
+    match = re.match(r"member (.+) (removed|added) by (.+)", text)
+    if match:
+        affected, action, actor = match.groups()
+        return action, extract_addr(affected), extract_addr(actor)
+
+    match = re.match(r"you (removed|added) member (.+)", text)
+    if match:
+        action, affected = match.groups()
+        return action, extract_addr(affected), "me"
+
+    if text.startswith("group left by "):
+        addr = extract_addr(text[13:])
+        if addr:
+            return "removed", addr, addr
+
+    return None
+
+
+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

{deltabot-cli-0.2.0 → deltabot-cli-1.0.0}/deltabot_cli/cli.py

@@ -1,4 +1,5 @@
 """Command Line Interface application"""
+
 import logging
 import os
 import time
@@ -8,11 +9,13 @@ from typing import Callable, Optional, Set, Union
 
 import qrcode
 from appdirs import user_config_dir
-from deltachat_rpc_client import AttrDict, Bot, DeltaChat, EventType, Rpc, const, events
-from deltachat_rpc_client.rpc import JsonRpcError
 from rich.logging import RichHandler
 
-from ._utils import ConfigProgressBar, parse_docstring
+from ._utils import AttrDict, ConfigProgressBar, parse_docstring
+from .client import Bot
+from .const import COMMAND_PREFIX, EventType
+from .events import EventFilter, HookCollection, NewMessage, RawEvent
+from .rpc import JsonRpcError, Rpc
 
 
 class BotCli:
@@ -28,12 +31,12 @@ class BotCli:
         self.log_level = log_level
         self._parser = ArgumentParser(app_name)
         self._subparsers = self._parser.add_subparsers(title="subcommands")
-        self._hooks = events.HookCollection()
+        self._hooks = HookCollection()
         self._init_hooks: Set[Callable[[Bot, Namespace], None]] = set()
         self._start_hooks: Set[Callable[[Bot, Namespace], None]] = set()
         self._bot: Bot
 
-    def on(self, event: Union[type, events.EventFilter]) -> Callable:  # noqa
+    def on(self, event: Union[type, EventFilter]) -> Callable:  # noqa
         """Register decorated function as listener for the given event."""
         return self._hooks.on(event)
 
@@ -62,9 +65,9 @@ class BotCli:
             func(bot, args)
 
     def is_not_known_command(self, event: AttrDict) -> bool:
-        if not event.command.startswith(const.COMMAND_PREFIX):
+        if not event.command.startswith(COMMAND_PREFIX):
             return True
-        for hook in self._bot._hooks.get(events.NewMessage, []):  # pylint:disable=W0212
+        for hook in self._bot._hooks.get(NewMessage, []):  # pylint:disable=W0212
             if event.command == hook[1].command:
                 return False
         return True
@@ -77,7 +80,7 @@ class BotCli:
 
     def add_subcommand(
         self,
-        func: Callable[[Bot, Namespace], None],
+        func: Callable[["BotCli", Bot, Namespace], None],
         **kwargs,
     ) -> ArgumentParser:
         """Add a subcommand to the CLI."""
@@ -123,7 +126,7 @@ class BotCli:
         config_parser.add_argument("option", help="option name", nargs="?")
         config_parser.add_argument("value", help="option value to set", nargs="?")
 
-        self.add_subcommand(self._serve_cmd, name="serve")
+        self.add_subcommand(_serve_cmd, name="serve")
         self.add_subcommand(_qr_cmd, name="qr")
 
     def get_accounts_dir(self, args: Namespace) -> str:
@@ -132,6 +135,28 @@ class BotCli:
             os.makedirs(args.config_dir)
         return os.path.join(args.config_dir, "accounts")
 
+    def get_or_create_account(self, rpc: Rpc, addr: str) -> int:
+        """Get account for address, if no account exists create a new one."""
+        accid = self.get_account(rpc, addr)
+        if not accid:
+            accid = rpc.add_account()
+            rpc.set_config(accid, "addr", addr)
+        return accid
+
+    def get_account(self, rpc: Rpc, addr: str) -> int:
+        """Get account id for address.
+        If no account exists with the given address, zero is returned.
+        """
+        for accid in rpc.get_all_account_ids():
+            if addr == self.get_address(rpc, accid):
+                return accid
+        return 0
+
+    def get_address(self, rpc: Rpc, accid: int) -> str:
+        if rpc.is_configured(accid):
+            return rpc.get_config(accid, "configured_addr")
+        return rpc.get_config(accid, "addr")
+
     def start(self) -> None:
         """Start running the bot and processing incoming messages."""
         self.init_parser()
@@ -144,37 +169,43 @@ class BotCli:
         accounts_dir = self.get_accounts_dir(args)
 
         with Rpc(accounts_dir=accounts_dir) as rpc:
-            deltachat = DeltaChat(rpc)
-            accounts = deltachat.get_all_accounts()
-            account = accounts[0] if accounts else deltachat.add_account()
-
-            self._bot = Bot(account, self._hooks)
+            self._bot = Bot(rpc, self._hooks)
             self._on_init(self._bot, args)
 
-            core_version = deltachat.get_system_info().deltachat_core_version
+            core_version = rpc.get_system_info().deltachat_core_version
             self._bot.logger.info("Running deltachat core %s", core_version)
             if "cmd" in args:
-                args.cmd(self._bot, args)
+                args.cmd(self, self._bot, args)
             else:
                 self._parser.parse_args(["-h"])
 
-    def _serve_cmd(self, bot: Bot, args: Namespace) -> None:
-        """start processing messages"""
-        if bot.is_configured():
-            self._on_start(bot, args)
-            while True:
-                try:
-                    bot.run_forever()
-                except KeyboardInterrupt:
-                    return
-                except Exception as ex:  # pylint:disable=W0703
-                    logging.exception(ex)
-                    time.sleep(5)
+
+def _serve_cmd(cli: BotCli, bot: Bot, args: Namespace) -> None:
+    """start processing messages"""
+    rpc = bot.rpc
+    accounts = rpc.get_all_account_ids()
+    addrs = []
+    for accid in accounts:
+        if rpc.is_configured(accid):
+            addrs.append(rpc.get_config(accid, "configured_addr"))
         else:
-            logging.error("Account is not configured")
+            logging.error(f"account {accid} not configured")
+    if len(addrs) != 0:
+        logging.info(f"Listening at: {', '.join(addrs)}")
+        cli._on_start(bot, args)  # noqa
+        while True:
+            try:
+                bot.run_forever()
+            except KeyboardInterrupt:
+                return
+            except Exception as ex:  # pylint:disable=W0703
+                logging.exception(ex)
+                time.sleep(5)
+    else:
+        logging.error("There are no configured accounts to serve")
 
 
-def _init_cmd(bot: Bot, args: Namespace) -> None:
+def _init_cmd(cli: BotCli, bot: Bot, args: Namespace) -> None:
     """initialize the account"""
 
     def on_progress(event: AttrDict) -> None:
@@ -184,13 +215,15 @@ def _init_cmd(bot: Bot, args: Namespace) -> None:
 
     def configure() -> None:
         try:
-            bot.configure(email=args.addr, password=args.password)
+            bot.configure(accid, email=args.addr, password=args.password)
         except JsonRpcError as err:
             logging.error(err)
 
+    accid = cli.get_or_create_account(bot.rpc, args.addr)
+
     logging.info("Starting configuration process...")
     pbar = ConfigProgressBar()
-    bot.add_hook(on_progress, events.RawEvent(EventType.CONFIGURE_PROGRESS))
+    bot.add_hook(on_progress, RawEvent(EventType.CONFIGURE_PROGRESS))
     task = Thread(target=configure)
     task.start()
     bot.run_until(lambda _: pbar.progress in (-1, pbar.total))
@@ -202,28 +235,54 @@ def _init_cmd(bot: Bot, args: Namespace) -> None:
         logging.info("Account configured successfully.")
 
 
-def _config_cmd(bot: Bot, args: Namespace) -> None:
+def _config_cmd(cli: BotCli, bot: Bot, args: Namespace) -> None:
     """set/get account configuration values"""
+    accounts = bot.rpc.get_all_account_ids()
+    for accid in accounts:
+        addr = cli.get_address(bot.rpc, accid)
+        print(f"Account #{accid} ({addr}):")
+        _config_cmd_for_acc(bot.rpc, accid, args)
+        print("")
+    if not accounts:
+        logging.error("There are no accounts yet, add a new account using the init subcommand")
+
+
+def _config_cmd_for_acc(rpc: Rpc, accid: int, args: Namespace) -> None:
     if args.value:
-        bot.account.set_config(args.option, args.value)
+        rpc.set_config(accid, args.option, args.value)
 
     if args.option:
         try:
-            value = bot.account.get_config(args.option)
+            value = rpc.get_config(accid, args.option)
             print(f"{args.option}={value!r}")
         except JsonRpcError:
             logging.error("Unknown configuration option: %s", args.option)
     else:
-        keys = bot.account.get_config("sys.config_keys") or ""
+        keys = rpc.get_config(accid, "sys.config_keys") or ""
         for key in keys.split():
-            value = bot.account.get_config(key)
+            value = rpc.get_config(accid, key)
             print(f"{key}={value!r}")
 
 
-def _qr_cmd(bot: Bot, _args: Namespace) -> None:
+def _qr_cmd(cli: BotCli, bot: Bot, _args: Namespace) -> None:
     """get bot's verification QR"""
-    qrdata, _ = bot.account.get_qr_code()
-    code = qrcode.QRCode()
-    code.add_data(qrdata)
-    code.print_ascii(invert=True)
-    print(qrdata)
+    accounts = bot.rpc.get_all_account_ids()
+    for accid in accounts:
+        addr = cli.get_address(bot.rpc, accid)
+        print(f"Account #{accid} ({addr}):")
+        _qr_cmd_for_acc(bot.rpc, accid)
+        print("")
+    if not accounts:
+        logging.error("There are no accounts yet, add a new account using the init subcommand")
+
+
+def _qr_cmd_for_acc(rpc: Rpc, accid: int) -> None:
+    """get bot's verification QR"""
+    if rpc.is_configured(accid):
+        qrdata, _ = rpc.get_chat_securejoin_qr_code_svg(accid, None)
+        code = qrcode.QRCode()
+        code.add_data(qrdata)
+        code.print_ascii(invert=True)
+        print(qrdata)
+    else:
+        logging.error("account not configured")