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

deltabot-cli-3.0.0/.github/workflows/python-ci.yml

@@ -0,0 +1,56 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+    tags:
+      - '*.*.*'
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.9', '3.11']
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install '.[dev]'
+    - name: Check code with black
+      run: |
+        black --check .
+    - name: Lint code
+      run: |
+        pylama
+    - name: Test with pytest
+      run: |
+        #pytest
+
+  deploy:
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
+        with:
+          python-version: '3.x'
+      - id: check-tag
+        run: |
+          if [[ "${{ github.event.ref }}" =~ ^refs/tags/[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+              echo ::set-output name=match::true
+          fi
+      - name: Create PyPI release
+        uses: casperdcl/deploy-pypi@v2
+        with:
+          password: ${{ secrets.PYPI_TOKEN }}
+          build: true
+          # only upload if a tag is pushed (otherwise just build & check)
+          upload: ${{ github.event_name == 'push' && steps.check-tag.outputs.match == 'true' }}

deltabot-cli-3.0.0/.gitignore

@@ -0,0 +1,13 @@
+__pycache__
+.cache
+.mypy_cache
+.pytest_cache
+build
+dist
+.eggs
+*.egg-info
+*/_version.py
+
+*~
+.#*
+*#

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

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: deltabot-cli
-Version: 1.0.0
+Version: 3.0.0
 Summary: Library to speedup Delta Chat bot development
-Author-email: adbenitez <adbenitez@hispanilandia.net>
+Author-email: adbenitez <adb@merlinux.eu>
 Keywords: deltachat,bot,deltabot-cli
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3
 Classifier: Intended Audience :: Developers
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: deltachat-rpc-server>=1.133.2
@@ -44,19 +44,18 @@ pip install deltabot-cli
 Example echo-bot written with deltabot-cli:
 
 ```python
-import logging
 from deltabot_cli import BotCli, events
 
 cli = BotCli("echobot")
 
 @cli.on(events.RawEvent)
-def log_event(event):
-    logging.info(event)
+def log_event(bot, accid, event):
+    bot.logger.info(event)
 
 @cli.on(events.NewMessage)
-def echo(event):
+def echo(bot, accid, event):
     msg = event.msg
-    event.rpc.misc_send_text_message(event.accid, msg.chat_id, msg.text)
+    bot.rpc.misc_send_text_message(accid, msg.chat_id, msg.text)
 
 if __name__ == "__main__":
     cli.start()
@@ -65,4 +64,4 @@ if __name__ == "__main__":
 If you run the above script you will have a bot CLI, that allows to configure and run a bot.
 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.
+For more examples check the [examples](./examples) folder.

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

@@ -20,19 +20,18 @@ pip install deltabot-cli
 Example echo-bot written with deltabot-cli:
 
 ```python
-import logging
 from deltabot_cli import BotCli, events
 
 cli = BotCli("echobot")
 
 @cli.on(events.RawEvent)
-def log_event(event):
-    logging.info(event)
+def log_event(bot, accid, event):
+    bot.logger.info(event)
 
 @cli.on(events.NewMessage)
-def echo(event):
+def echo(bot, accid, event):
     msg = event.msg
-    event.rpc.misc_send_text_message(event.accid, msg.chat_id, msg.text)
+    bot.rpc.misc_send_text_message(accid, msg.chat_id, msg.text)
 
 if __name__ == "__main__":
     cli.start()
@@ -41,4 +40,4 @@ if __name__ == "__main__":
 If you run the above script you will have a bot CLI, that allows to configure and run a bot.
 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.
+For more examples check the [examples](./examples) folder.

{deltabot-cli-1.0.0 → deltabot-cli-3.0.0}/deltabot_cli/__init__.py

@@ -6,3 +6,4 @@ from .cli import BotCli
 from .client import Bot
 from .const import *
 from .rpc import JsonRpcError, Rpc
+from .utils import is_not_known_command

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

@@ -13,10 +13,13 @@ from rich.logging import RichHandler
 
 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 .const import EventType
+from .events import EventFilter, HookCollection, HookDecorator, RawEvent
 from .rpc import JsonRpcError, Rpc
 
+CliEventHook = Callable[[Bot, Namespace], None]
+CmdCallback = Callable[["BotCli", Bot, Namespace], None]
+
 
 class BotCli:
     """Class implementing a bot CLI.
@@ -32,15 +35,15 @@ class BotCli:
         self._parser = ArgumentParser(app_name)
         self._subparsers = self._parser.add_subparsers(title="subcommands")
         self._hooks = HookCollection()
-        self._init_hooks: Set[Callable[[Bot, Namespace], None]] = set()
-        self._start_hooks: Set[Callable[[Bot, Namespace], None]] = set()
+        self._init_hooks: Set[CliEventHook] = set()
+        self._start_hooks: Set[CliEventHook] = set()
         self._bot: Bot
 
-    def on(self, event: Union[type, EventFilter]) -> Callable:  # noqa
+    def on(self, event: Union[type, EventFilter]) -> HookDecorator:  # noqa
         """Register decorated function as listener for the given event."""
         return self._hooks.on(event)
 
-    def on_init(self, func: Callable[[Bot, Namespace], None]) -> Callable:
+    def on_init(self, func: CliEventHook) -> CliEventHook:
         """Register function to be called before the bot starts serving requests.
 
         The function will receive the bot instance and the CLI arguments received.
@@ -52,7 +55,7 @@ class BotCli:
         for func in self._init_hooks:
             func(bot, args)
 
-    def on_start(self, func: Callable[[Bot, Namespace], None]) -> Callable:
+    def on_start(self, func: CliEventHook) -> CliEventHook:
         """Register function to be called when the bot is about to start serving requests.
 
         The function will receive the bot instance.
@@ -64,14 +67,6 @@ class BotCli:
         for func in self._start_hooks:
             func(bot, args)
 
-    def is_not_known_command(self, event: AttrDict) -> bool:
-        if not event.command.startswith(COMMAND_PREFIX):
-            return True
-        for hook in self._bot._hooks.get(NewMessage, []):  # pylint:disable=W0212
-            if event.command == hook[1].command:
-                return False
-        return True
-
     def add_generic_option(self, *flags, **kwargs) -> None:
         """Add a generic argument option to the CLI."""
         if not (flags and flags[0].startswith("-")):
@@ -80,7 +75,7 @@ class BotCli:
 
     def add_subcommand(
         self,
-        func: Callable[["BotCli", Bot, Namespace], None],
+        func: CmdCallback,
         **kwargs,
     ) -> ArgumentParser:
         """Add a subcommand to the CLI."""
@@ -189,9 +184,9 @@ def _serve_cmd(cli: BotCli, bot: Bot, args: Namespace) -> None:
         if rpc.is_configured(accid):
             addrs.append(rpc.get_config(accid, "configured_addr"))
         else:
-            logging.error(f"account {accid} not configured")
+            bot.logger.error(f"account {accid} not configured")
     if len(addrs) != 0:
-        logging.info(f"Listening at: {', '.join(addrs)}")
+        bot.logger.info(f"Listening at: {', '.join(addrs)}")
         cli._on_start(bot, args)  # noqa
         while True:
             try:
@@ -199,10 +194,10 @@ def _serve_cmd(cli: BotCli, bot: Bot, args: Namespace) -> None:
             except KeyboardInterrupt:
                 return
             except Exception as ex:  # pylint:disable=W0703
-                logging.exception(ex)
+                bot.logger.exception(ex)
                 time.sleep(5)
     else:
-        logging.error("There are no configured accounts to serve")
+        bot.logger.error("There are no configured accounts to serve")
 
 
 def _init_cmd(cli: BotCli, bot: Bot, args: Namespace) -> None:
@@ -210,18 +205,18 @@ def _init_cmd(cli: BotCli, bot: Bot, args: Namespace) -> None:
 
     def on_progress(event: AttrDict) -> None:
         if event.comment:
-            logging.info(event.comment)
+            bot.logger.info(event.comment)
         pbar.set_progress(event.progress)
 
     def configure() -> None:
         try:
             bot.configure(accid, email=args.addr, password=args.password)
         except JsonRpcError as err:
-            logging.error(err)
+            bot.logger.error(err)
 
     accid = cli.get_or_create_account(bot.rpc, args.addr)
 
-    logging.info("Starting configuration process...")
+    bot.logger.info("Starting configuration process...")
     pbar = ConfigProgressBar()
     bot.add_hook(on_progress, RawEvent(EventType.CONFIGURE_PROGRESS))
     task = Thread(target=configure)
@@ -230,9 +225,9 @@ def _init_cmd(cli: BotCli, bot: Bot, args: Namespace) -> None:
     task.join()
     pbar.close()
     if pbar.progress == -1:
-        logging.error("Configuration failed.")
+        bot.logger.error("Configuration failed.")
     else:
-        logging.info("Account configured successfully.")
+        bot.logger.info("Account configured successfully.")
 
 
 def _config_cmd(cli: BotCli, bot: Bot, args: Namespace) -> None:
@@ -241,26 +236,26 @@ def _config_cmd(cli: BotCli, bot: Bot, args: Namespace) -> None:
     for accid in accounts:
         addr = cli.get_address(bot.rpc, accid)
         print(f"Account #{accid} ({addr}):")
-        _config_cmd_for_acc(bot.rpc, accid, args)
+        _config_cmd_for_acc(bot, accid, args)
         print("")
     if not accounts:
-        logging.error("There are no accounts yet, add a new account using the init subcommand")
+        bot.logger.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:
+def _config_cmd_for_acc(bot: Bot, accid: int, args: Namespace) -> None:
     if args.value:
-        rpc.set_config(accid, args.option, args.value)
+        bot.rpc.set_config(accid, args.option, args.value)
 
     if args.option:
         try:
-            value = rpc.get_config(accid, args.option)
+            value = bot.rpc.get_config(accid, args.option)
             print(f"{args.option}={value!r}")
         except JsonRpcError:
-            logging.error("Unknown configuration option: %s", args.option)
+            bot.logger.error("Unknown configuration option: %s", args.option)
     else:
-        keys = rpc.get_config(accid, "sys.config_keys") or ""
+        keys = bot.rpc.get_config(accid, "sys.config_keys") or ""
         for key in keys.split():
-            value = rpc.get_config(accid, key)
+            value = bot.rpc.get_config(accid, key)
             print(f"{key}={value!r}")
 
 
@@ -270,19 +265,19 @@ def _qr_cmd(cli: BotCli, bot: Bot, _args: Namespace) -> None:
     for accid in accounts:
         addr = cli.get_address(bot.rpc, accid)
         print(f"Account #{accid} ({addr}):")
-        _qr_cmd_for_acc(bot.rpc, accid)
+        _qr_cmd_for_acc(bot, accid)
         print("")
     if not accounts:
-        logging.error("There are no accounts yet, add a new account using the init subcommand")
+        bot.logger.error("There are no accounts yet, add a new account using the init subcommand")
 
 
-def _qr_cmd_for_acc(rpc: Rpc, accid: int) -> None:
+def _qr_cmd_for_acc(bot: Bot, accid: int) -> None:
     """get bot's verification QR"""
-    if rpc.is_configured(accid):
-        qrdata, _ = rpc.get_chat_securejoin_qr_code_svg(accid, None)
+    if bot.rpc.is_configured(accid):
+        qrdata, _ = bot.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")
+        bot.logger.error("account not configured")

{deltabot-cli-1.0.0 → deltabot-cli-3.0.0}/deltabot_cli/client.py

@@ -14,6 +14,7 @@ from .events import (
     EventFilter,
     GroupImageChanged,
     GroupNameChanged,
+    HookCallback,
     MemberListChanged,
     NewMessage,
     RawEvent,
@@ -27,7 +28,7 @@ class Client:
     def __init__(
         self,
         rpc: Rpc,
-        hooks: Optional[Iterable[Tuple[Callable, Union[type, EventFilter]]]] = None,
+        hooks: Optional[Iterable[Tuple[HookCallback, Union[type, EventFilter]]]] = None,
         logger: Optional[logging.Logger] = None,
     ) -> None:
         self.rpc = rpc
@@ -36,11 +37,11 @@ class Client:
         self._should_process_messages = 0
         self.add_hooks(hooks or [])
 
-    def add_hooks(self, hooks: Iterable[Tuple[Callable, Union[type, EventFilter]]]) -> None:
+    def add_hooks(self, hooks: Iterable[Tuple[HookCallback, Union[type, EventFilter]]]) -> None:
         for hook, event in hooks:
             self.add_hook(hook, event)
 
-    def add_hook(self, hook: Callable, event: Union[type, EventFilter] = RawEvent) -> None:
+    def add_hook(self, hook: HookCallback, event: Union[type, EventFilter] = RawEvent) -> None:
         """Register hook for the given event filter."""
         if isinstance(event, type):
             event = event()
@@ -53,7 +54,7 @@ class Client:
         )
         self._hooks.setdefault(type(event), set()).add((hook, event))
 
-    def remove_hook(self, hook: Callable, event: Union[type, EventFilter]) -> None:
+    def remove_hook(self, hook: HookCallback, event: Union[type, EventFilter]) -> None:
         """Unregister hook from the given event filter."""
         if isinstance(event, type):
             event = event()
@@ -91,30 +92,33 @@ class Client:
                 self._process_messages(accid)  # Process old messages.
         while True:
             raw_event = self.rpc.get_next_event()
-            event = AttrDict(rpc=self.rpc, accid=raw_event.context_id, **raw_event.event)
-            self._on_event(event)
+            accid = raw_event.context_id
+            event = raw_event.event
+            self._on_event(accid, event)
             if event.kind == EventType.INCOMING_MSG:
-                self._process_messages(event.accid)
+                self._process_messages(accid)
 
             if func(event):
                 return event
 
-    def _on_event(self, event: AttrDict, filter_type: Type[EventFilter] = RawEvent) -> None:
+    def _on_event(
+        self, accid: int, event: AttrDict, filter_type: Type[EventFilter] = RawEvent
+    ) -> None:
         for hook, evfilter in self._hooks.get(filter_type, []):
             if evfilter.filter(event):
                 try:
-                    hook(event)
+                    hook(self, accid, event)
                 except Exception as ex:
                     self.logger.exception(ex)
 
-    def _parse_command(self, event: AttrDict) -> None:
+    def _parse_command(self, accid: int, event: AttrDict) -> None:
         cmds = [hook[1].command for hook in self._hooks.get(NewMessage, []) if hook[1].command]
         parts = event.msg.text.split(maxsplit=1)
         payload = parts[1] if len(parts) > 1 else ""
         cmd = parts.pop(0)
 
         if "@" in cmd:
-            suffix = "@" + self.rpc.get_contact(event.accid, SpecialContactId.SELF).address
+            suffix = "@" + self.rpc.get_contact(accid, SpecialContactId.SELF).address
             if cmd.endswith(suffix):
                 cmd = cmd[: -len(suffix)]
             else:
@@ -135,31 +139,31 @@ class Client:
         event["command"], event["payload"] = cmd, payload
 
     def _on_new_msg(self, accid: int, msg: AttrDict) -> None:
-        event = AttrDict(rpc=self.rpc, accid=accid, command="", payload="", msg=msg)
+        event = AttrDict(command="", payload="", msg=msg)
         if not msg.is_info and msg.text.startswith(COMMAND_PREFIX):
-            self._parse_command(event)
-        self._on_event(event, NewMessage)
+            self._parse_command(accid, event)
+        self._on_event(accid, event, NewMessage)
 
     def _handle_info_msg(self, accid: int, snapshot: AttrDict) -> None:
-        event = AttrDict(rpc=self.rpc, accid=accid, msg=snapshot)
+        event = AttrDict(msg=snapshot)
 
         img_changed = parse_system_image_changed(snapshot.text)
         if img_changed:
             _, event["image_deleted"] = img_changed
-            self._on_event(event, GroupImageChanged)
+            self._on_event(accid, event, GroupImageChanged)
             return
 
         title_changed = parse_system_title_changed(snapshot.text)
         if title_changed:
             _, event["old_name"] = title_changed
-            self._on_event(event, GroupNameChanged)
+            self._on_event(accid, event, GroupNameChanged)
             return
 
         members_changed = parse_system_add_remove(snapshot.text)
         if members_changed:
             action, event["member"], _ = members_changed
             event["member_added"] = action == "added"
-            self._on_event(event, MemberListChanged)
+            self._on_event(accid, event, MemberListChanged)
             return
 
         self.logger.warning(

{deltabot-cli-1.0.0 → deltabot-cli-3.0.0}/deltabot_cli/events.py

@@ -17,6 +17,10 @@ from .const import EventType
 
 if TYPE_CHECKING:
     from ._utils import AttrDict
+    from .client import Bot
+FilterCallback = Callable[["Bot", "AttrDict"], bool]
+HookCallback = Callable[["Bot", "AttrDict"], None]
+HookDecorator = Callable[[HookCallback], HookCallback]
 
 
 def _tuple_of(obj, type_: type) -> tuple:
@@ -33,12 +37,11 @@ def _tuple_of(obj, type_: type) -> tuple:
 class EventFilter(ABC):
     """The base event filter.
 
-    :param func: A Callable function that should accept the event as input
-                 parameter, and return a bool value indicating whether the event
-                 should be dispatched or not.
+    :param func: A Callable that should accept the bot and event as input parameters,
+                 and return a bool value indicating whether the event should be dispatched or not.
     """
 
-    def __init__(self, func: Optional[Callable] = None):
+    def __init__(self, func: Optional[FilterCallback] = None):
         self.func = func
 
     @abstractmethod
@@ -52,13 +55,13 @@ class EventFilter(ABC):
     def __ne__(self, other):
         return not self == other
 
-    def _call_func(self, event) -> bool:
+    def _call_func(self, bot: "Bot", event: "AttrDict") -> bool:
         if not self.func:
             return True
-        return self.func(event)
+        return self.func(bot, event)
 
     @abstractmethod
-    def filter(self, event):
+    def filter(self, bot: "Bot", event: "AttrDict"):
         """Return True-like value if the event passed the filter and should be
         used, or False-like value otherwise.
         """
@@ -68,13 +71,16 @@ class RawEvent(EventFilter):
     """Matches raw core events.
 
     :param types: The types of event to match.
-    :param func: A Callable function that should accept the event as input
-                 parameter, and return a bool value indicating whether the event
-                 should be dispatched or not.
+    :param func: A Callable that should accept the bot and event as input parameter,
+                 and return a bool value indicating whether the event should be dispatched or not.
     """
 
-    def __init__(self, types: Union[None, EventType, Iterable[EventType]] = None, **kwargs):
-        super().__init__(**kwargs)
+    def __init__(
+        self,
+        types: Union[None, EventType, Iterable[EventType]] = None,
+        func: Optional[FilterCallback] = None,
+    ):
+        super().__init__(func=func)
         try:
             self.types = _tuple_of(types, EventType)
         except TypeError as err:
@@ -88,10 +94,10 @@ class RawEvent(EventFilter):
             return (self.types, self.func) == (other.types, other.func)
         return False
 
-    def filter(self, event: "AttrDict") -> bool:
+    def filter(self, bot: "Bot", event: "AttrDict") -> bool:
         if self.types and event.kind not in self.types:
             return False
-        return self._call_func(event)
+        return self._call_func(bot, event)
 
 
 class NewMessage(EventFilter):
@@ -110,9 +116,8 @@ class NewMessage(EventFilter):
     :param is_info: If set to True only match info/system messages, if set to False
                     only match messages that are not info/system messages. If omitted
                     info/system messages as well as normal messages will be matched.
-    :param func: A Callable function that should accept the event as input
-                 parameter, and return a bool value indicating whether the event
-                 should be dispatched or not.
+    :param func: A Callable that should accept the bot and the event as input parameter,
+                 and return a bool value indicating whether the event should be dispatched or not.
     """
 
     def __init__(
@@ -126,7 +131,7 @@ class NewMessage(EventFilter):
         command: Optional[str] = None,
         is_bot: Optional[bool] = False,
         is_info: Optional[bool] = None,
-        func: Optional[Callable[["AttrDict"], bool]] = None,
+        func: Optional[FilterCallback] = None,
     ) -> None:
         super().__init__(func=func)
         self.is_bot = is_bot
@@ -165,7 +170,7 @@ class NewMessage(EventFilter):
             )
         return False
 
-    def filter(self, event: "AttrDict") -> bool:
+    def filter(self, bot: "Bot", event: "AttrDict") -> bool:
         if self.is_bot is not None and self.is_bot != event.msg.is_bot:
             return False
         if self.is_info is not None and self.is_info != event.msg.is_info:
@@ -176,7 +181,7 @@ class NewMessage(EventFilter):
             match = self.pattern(event.msg.text)
             if not match:
                 return False
-        return super()._call_func(event)
+        return super()._call_func(bot, event)
 
 
 class MemberListChanged(EventFilter):
@@ -188,9 +193,8 @@ class MemberListChanged(EventFilter):
     :param added: If set to True only match if a member was added, if set to False
                   only match if a member was removed. If omitted both, member additions
                   and removals, will be matched.
-    :param func: A Callable function that should accept the event as input
-                 parameter, and return a bool value indicating whether the event
-                 should be dispatched or not.
+    :param func: A Callable that should accept the bot and event as input parameter,
+                 and return a bool value indicating whether the event should be dispatched or not.
     """
 
     def __init__(self, added: Optional[bool] = None, **kwargs):
@@ -205,10 +209,10 @@ class MemberListChanged(EventFilter):
             return (self.added, self.func) == (other.added, other.func)
         return False
 
-    def filter(self, event: "AttrDict") -> bool:
+    def filter(self, bot: "Bot", event: "AttrDict") -> bool:
         if self.added is not None and self.added != event.member_added:
             return False
-        return self._call_func(event)
+        return self._call_func(bot, event)
 
 
 class GroupImageChanged(EventFilter):
@@ -220,9 +224,8 @@ class GroupImageChanged(EventFilter):
     :param deleted: If set to True only match if the image was deleted, if set to False
                     only match if a new image was set. If omitted both, image changes and
                     removals, will be matched.
-    :param func: A Callable function that should accept the event as input
-                 parameter, and return a bool value indicating whether the event
-                 should be dispatched or not.
+    :param func: A Callable that should accept the bot and event as input parameter,
+                 and return a bool value indicating whether the event should be dispatched or not.
     """
 
     def __init__(self, deleted: Optional[bool] = None, **kwargs):
@@ -237,10 +240,10 @@ class GroupImageChanged(EventFilter):
             return (self.deleted, self.func) == (other.deleted, other.func)
         return False
 
-    def filter(self, event: "AttrDict") -> bool:
+    def filter(self, bot: "Bot", event: "AttrDict") -> bool:
         if self.deleted is not None and self.deleted != event.image_deleted:
             return False
-        return self._call_func(event)
+        return self._call_func(bot, event)
 
 
 class GroupNameChanged(EventFilter):
@@ -249,9 +252,8 @@ class GroupNameChanged(EventFilter):
     Warning: registering a handler for this event will cause the messages
     to be marked as read. Its usage is mainly intended for bots.
 
-    :param func: A Callable function that should accept the event as input
-                 parameter, and return a bool value indicating whether the event
-                 should be dispatched or not.
+    :param func: A Callable that should accept the bot and event as input parameter,
+                 and return a bool value indicating whether the event should be dispatched or not.
     """
 
     def __hash__(self) -> int:
@@ -262,8 +264,8 @@ class GroupNameChanged(EventFilter):
             return self.func == other.func
         return False
 
-    def filter(self, event: "AttrDict") -> bool:
-        return self._call_func(event)
+    def filter(self, bot: "Bot", event: "AttrDict") -> bool:
+        return self._call_func(bot, event)
 
 
 class HookCollection:
@@ -272,18 +274,18 @@ class HookCollection:
     """
 
     def __init__(self) -> None:
-        self._hooks: Set[Tuple[Callable, Union[type, EventFilter]]] = set()
+        self._hooks: Set[Tuple[HookCallback, Union[type, EventFilter]]] = set()
 
-    def __iter__(self) -> Iterator[Tuple[Callable, Union[type, EventFilter]]]:
+    def __iter__(self) -> Iterator[Tuple[HookCallback, Union[type, EventFilter]]]:
         return iter(self._hooks)
 
-    def on(self, event: Union[type, EventFilter]) -> Callable:  # noqa
+    def on(self, event: Union[type, EventFilter]) -> HookDecorator:  # noqa
         """Register decorated function as listener for the given event."""
         if isinstance(event, type):
             event = event()
         assert isinstance(event, EventFilter), "Invalid event filter"
 
-        def _decorator(func) -> Callable:
+        def _decorator(func: HookCallback) -> HookCallback:
             self._hooks.add((func, event))
             return func
 

deltabot-cli-3.0.0/deltabot_cli/utils.py

@@ -0,0 +1,17 @@
+"""Utilities"""
+
+from ._utils import AttrDict
+from .client import Bot
+from .const import COMMAND_PREFIX
+from .events import NewMessage
+
+
+def is_not_known_command(bot: Bot, event: AttrDict) -> bool:
+    """Filter helper to be used by NewMessage filters.
+    Matches all NewMessage that don't match a previously registered command filter."""
+    if not event.command.startswith(COMMAND_PREFIX):
+        return True
+    for hook in bot._hooks.get(NewMessage, []):  # pylint:disable=W0212
+        if event.command == hook[1].command:
+            return False
+    return True

{deltabot-cli-1.0.0 → deltabot-cli-3.0.0}/deltabot_cli.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: deltabot-cli
-Version: 1.0.0
+Version: 3.0.0
 Summary: Library to speedup Delta Chat bot development
-Author-email: adbenitez <adbenitez@hispanilandia.net>
+Author-email: adbenitez <adb@merlinux.eu>
 Keywords: deltachat,bot,deltabot-cli
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3
 Classifier: Intended Audience :: Developers
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: deltachat-rpc-server>=1.133.2
@@ -44,19 +44,18 @@ pip install deltabot-cli
 Example echo-bot written with deltabot-cli:
 
 ```python
-import logging
 from deltabot_cli import BotCli, events
 
 cli = BotCli("echobot")
 
 @cli.on(events.RawEvent)
-def log_event(event):
-    logging.info(event)
+def log_event(bot, accid, event):
+    bot.logger.info(event)
 
 @cli.on(events.NewMessage)
-def echo(event):
+def echo(bot, accid, event):
     msg = event.msg
-    event.rpc.misc_send_text_message(event.accid, msg.chat_id, msg.text)
+    bot.rpc.misc_send_text_message(accid, msg.chat_id, msg.text)
 
 if __name__ == "__main__":
     cli.start()
@@ -65,4 +64,4 @@ if __name__ == "__main__":
 If you run the above script you will have a bot CLI, that allows to configure and run a bot.
 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.
+For more examples check the [examples](./examples) folder.

{deltabot-cli-1.0.0 → deltabot-cli-3.0.0}/deltabot_cli.egg-info/SOURCES.txt

@@ -1,6 +1,9 @@
+.gitignore
 LICENSE
 README.md
+pylama.ini
 pyproject.toml
+.github/workflows/python-ci.yml
 deltabot_cli/__init__.py
 deltabot_cli/_utils.py
 deltabot_cli/cli.py
@@ -8,8 +11,11 @@ deltabot_cli/client.py
 deltabot_cli/const.py
 deltabot_cli/events.py
 deltabot_cli/rpc.py
+deltabot_cli/utils.py
 deltabot_cli.egg-info/PKG-INFO
 deltabot_cli.egg-info/SOURCES.txt
 deltabot_cli.egg-info/dependency_links.txt
 deltabot_cli.egg-info/requires.txt
-deltabot_cli.egg-info/top_level.txt
+deltabot_cli.egg-info/top_level.txt
+examples/echobot.py
+examples/echobot_advanced.py

deltabot-cli-3.0.0/examples/echobot.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+"""Minimal echo-bot example."""
+
+from deltabot_cli import BotCli, events
+
+cli = BotCli("echobot")
+
+
+@cli.on(events.RawEvent)
+def log_event(bot, _accid, event):
+    bot.logger.info(event)
+
+
+@cli.on(events.NewMessage)
+def echo(bot, accid, event):
+    msg = event.msg
+    bot.rpc.misc_send_text_message(accid, msg.chat_id, msg.text)
+
+
+if __name__ == "__main__":
+    cli.start()

deltabot-cli-3.0.0/examples/echobot_advanced.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""Advanced echo bot example."""
+from deltabot_cli import BotCli, EventType, events
+
+cli = BotCli("echobot")
+
+
+@cli.on(events.RawEvent)
+def log_event(bot, _accid, event):
+    if event.kind == EventType.INFO:
+        bot.logger.info(event.msg)
+    elif event.kind == EventType.WARNING:
+        bot.logger.warning(event.msg)
+    elif event.kind == EventType.ERROR:
+        bot.logger.error(event.msg)
+
+
+@cli.on(events.NewMessage)
+def echo(bot, accid, event):
+    msg = event.msg
+    bot.rpc.misc_send_text_message(accid, msg.chat_id, msg.text)
+
+
+@cli.on_init
+def on_init(bot, args):
+    bot.logger.info("Initializing bot with args: %s", args)
+
+
+@cli.on_start
+def on_start(bot, _args):
+    bot.logger.info("Running bot...")
+
+
+def test(_cli, bot, args):
+    """just some example subcommand"""
+    bot.logger.info("Hello %s, this is an example subcommand!", args.name)
+
+
+if __name__ == "__main__":
+    subcmd = cli.add_subcommand(test)
+    subcmd.add_argument("name", help="your name")
+
+    try:
+        cli.start()
+    except KeyboardInterrupt:
+        pass

deltabot-cli-3.0.0/pylama.ini

@@ -0,0 +1,4 @@
+[pylama]
+linters=mccabe,pyflakes,pylint,isort,mypy
+ignore=C0116,R0902,R0913,W1203,W0718
+skip=.*,build/*,tests/*,*/flycheck_*

{deltabot-cli-1.0.0 → deltabot-cli-3.0.0}/pyproject.toml

@@ -1,17 +1,17 @@
 [build-system]
-requires = ["setuptools"]
+requires = ["setuptools>=64", "setuptools_scm>=8"]
 build-backend = "setuptools.build_meta"
 
 [project]
-version = "1.0.0"
 name = "deltabot-cli"
 description = "Library to speedup Delta Chat bot development"
+dynamic = ["version"]
 readme = "README.md"
-requires-python = ">=3.7"
+requires-python = ">=3.8"
 license = {file = "LICENSE.txt"}
 keywords = ["deltachat", "bot", "deltabot-cli"]
 authors = [
-  {name = "adbenitez", email = "adbenitez@hispanilandia.net"},
+  {name = "adbenitez", email = "adb@merlinux.eu"},
 ]
 classifiers = [
   "Development Status :: 4 - Beta",
@@ -35,6 +35,9 @@ dev = [
   "pytest",
 ]
 
+[tool.setuptools_scm]
+# can be empty if no extra settings are needed, presence enables setuptools_scm
+
 [tool.black]
 line-length = 100