Union[chat1.Channel, Chat1.ConvIDStr] (#45)

* Union[chat1.Channel, Chat1.ConvIDStr]

* typos

* lint

* isort

* fmt

* ignore venv

* run acceptance tests

Author: joshblum

.flake8

@@ -5,4 +5,4 @@ max-complexity = 18
 select = B,C,E,F,W,T4,B9
 per-file-ignores =
   pykeybasebot/__init__.py:F401,F403
-exclude = pykeybasebot/types/
+exclude = pykeybasebot/types/,venv/

.gitignore

@@ -4,3 +4,4 @@ __pycache__/
 .mypy_cache/
 test_config.yaml
 *.egg-info
+venv

pykeybasebot/bot.py

@@ -168,7 +168,7 @@ async def _initialize(self):
             # raise an exception because we can't authenticate
             raise Exception(f"failed to initialize with oneshot {oneshot_result}")
         await self.submit(
-            "chat notification-settings -disable-typing {self.disable_typing}"
+            f"chat notification-settings -disable-typing={self.disable_typing}"
         )
 
     async def teardown(self):

pykeybasebot/chat_client.py

@@ -1,5 +1,5 @@
 import json
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Tuple, Union
 
 from .errors import ChatClientError
 from .types import chat1
@@ -9,6 +9,13 @@ class ChatClient:
     def __init__(self, bot):
         self.bot = bot
 
+    def _channel_or_conv_id(
+        self, channel: Union[chat1.ChatChannel, chat1.ConvIDStr]
+    ) -> Tuple[str, Union[str, dict]]:
+        if isinstance(channel, chat1.ChatChannel):
+            return "channel", channel.to_dict()
+        return "conversation_id", str(channel)
+
     async def list(self) -> List[chat1.ConvSummary]:
         """
         Lists your chats, with info on which ones have unread messages.
@@ -19,45 +26,50 @@ async def list(self) -> List[chat1.ConvSummary]:
         return chat_list.conversations or []
 
     async def read(
-        self, channel: chat1.ChatChannel, pagination: Optional[chat1.Pagination]
+        self,
+        channel: Union[chat1.ChatChannel, chat1.ConvIDStr],
+        pagination: Optional[chat1.Pagination] = None,
     ) -> List[Optional[chat1.MsgSummary]]:
         """
         Reads the messages in a channel.
         """
         await self.bot.ensure_initialized()
-        read_options = {"channel": channel.to_dict()}
+        ch_key, ch_val = self._channel_or_conv_id(channel)
+        read_options = {ch_key: ch_val}
         if pagination is not None:
             read_options["pagination"] = pagination.to_dict()
         read_request = {"method": "read", "params": {"options": read_options}}
         res = await self.execute(read_request)
         thread = chat1.Thread.from_dict(res)
         return [message.msg for message in (thread.messages or [])]
 
-    async def send(self, channel: chat1.ChatChannel, message: str) -> chat1.SendRes:
+    async def send(
+        self, channel: Union[chat1.ChatChannel, chat1.ConvIDStr], message: str
+    ) -> chat1.SendRes:
         await self.bot.ensure_initialized()
+        ch_key, ch_val = self._channel_or_conv_id(channel)
         res = await self.execute(
             {
                 "method": "send",
-                "params": {
-                    "options": {
-                        "channel": channel.to_dict(),
-                        "message": {"body": message},
-                    }
-                },
+                "params": {"options": {ch_key: ch_val, "message": {"body": message}}},
             }
         )
         return chat1.SendRes.from_dict(res)
 
     async def react(
-        self, channel: chat1.ChatChannel, message_id: chat1.MessageID, reaction: str
+        self,
+        channel: Union[chat1.ChatChannel, chat1.ConvIDStr],
+        message_id: chat1.MessageID,
+        reaction: str,
     ) -> chat1.SendRes:
         await self.bot.ensure_initialized()
+        ch_key, ch_val = self._channel_or_conv_id(channel)
         res = await self.execute(
             {
                 "method": "reaction",
                 "params": {
                     "options": {
-                        "channel": channel.to_dict(),
+                        ch_key: ch_val,
                         "message_id": message_id,
                         "message": {"body": reaction},
                     }
@@ -67,15 +79,19 @@ async def react(
         return chat1.SendRes.from_dict(res)
 
     async def edit(
-        self, channel: chat1.ChatChannel, message_id: chat1.MessageID, message: str
+        self,
+        channel: Union[chat1.ChatChannel, chat1.ConvIDStr],
+        message_id: chat1.MessageID,
+        message: str,
     ) -> chat1.SendRes:
         await self.bot.ensure_initialized()
+        ch_key, ch_val = self._channel_or_conv_id(channel)
         res = await self.execute(
             {
                 "method": "edit",
                 "params": {
                     "options": {
-                        "channel": channel.to_dict(),
+                        ch_key: ch_val,
                         "message_id": message_id,
                         "message": {"body": message},
                     }
@@ -85,33 +101,37 @@ async def edit(
         return chat1.SendRes.from_dict(res)
 
     async def attach(
-        self, channel: chat1.ChatChannel, filename: str, title: str
+        self,
+        channel: Union[chat1.ChatChannel, chat1.ConvIDStr],
+        filename: str,
+        title: str,
     ) -> chat1.SendRes:
         await self.bot.ensure_initialized()
+        ch_key, ch_val = self._channel_or_conv_id(channel)
         res = await self.execute(
             {
                 "method": "attach",
                 "params": {
-                    "options": {
-                        "channel": channel.to_dict(),
-                        "filename": filename,
-                        "title": title,
-                    }
+                    "options": {ch_key: ch_val, "filename": filename, "title": title}
                 },
             }
         )
         return chat1.SendRes.from_dict(res)
 
     async def download(
-        self, channel: chat1.ChatChannel, message_id: int, output: str
+        self,
+        channel: Union[chat1.ChatChannel, chat1.ConvIDStr],
+        message_id: int,
+        output: str,
     ) -> chat1.SendRes:
         await self.bot.ensure_initialized()
+        ch_key, ch_val = self._channel_or_conv_id(channel)
         res = await self.execute(
             {
                 "method": "download",
                 "params": {
                     "options": {
-                        "channel": channel.to_dict(),
+                        ch_key: ch_val,
                         "message_id": message_id,
                         "output": output,
                     }

tests/acceptance/chat_test.py

@@ -32,6 +32,11 @@ def channel(config):
     )
 
 
+@pytest.fixture()
+def conv_id(config):
+    return chat1.ConvIDStr(f"{config['teams']['acme']['conv_id']}")
+
+
 def noop_handler(*args, **kwargs):
     pass
 
@@ -80,3 +85,11 @@ async def test_read(setup_bot, channel):
     messages = await bot.chat.read(channel)
     for message in messages:
         assert type(message) is chat1.MsgSummary
+
+
+@pytest.mark.asyncio
+async def test_read_conv_id(setup_bot, conv_id):
+    bot = setup_bot("alice")
+    messages = await bot.chat.read(conv_id)
+    for message in messages:
+        assert type(message) is chat1.MsgSummary

tests/acceptance/test_config.example.yaml

@@ -14,3 +14,6 @@ teams:
     name: "acme"
     # The channel to use
     topicname: "mysupercoolchannel"
+    # ConvID of the channel, if you do a `list` in chat api you can find the
+    # convID. E.g. `keybase chat api -p -m '{"method": "read", "params": {"options": {"channel": {"name":"acme", "members_type":"team", "topic_name":"mysupercoolchannel"}}}}'`
+    conv_id: "00001bca4f13b0a7b81bfbc2acd7f8cf829bf53845ac87cdd8b62617d5aaa084"