remove f-format

Author: tbarbugli

stream_chat/channel.py

@@ -14,7 +14,7 @@ def __init__(self, client, channel_type, channel_id=None, custom_data=None):
     def url(self):
         if self.id is None:
             raise StreamChannelException("channel does not have an id")
-        return f"channels/{self.channel_type}/{self.id}"
+        return "channels/{}/{}".format(self.channel_type, self.id)
 
     def send_message(self, message, user_id):
         """
@@ -25,7 +25,7 @@ def send_message(self, message, user_id):
         :return: the Server Response
         """
         payload = {"message": add_user_id(message, user_id)}
-        return self.client.post(f"{self.url}/message", data=payload)
+        return self.client.post("{}/message".format(self.url), data=payload)
 
     def send_event(self, event, user_id):
         """
@@ -36,7 +36,7 @@ def send_event(self, event, user_id):
         :return: the Server Response
         """
         payload = {"event": add_user_id(event, user_id)}
-        return self.client.post(f"{self.url}/event", data=payload)
+        return self.client.post("{}/event".format(self.url), data=payload)
 
     def send_reaction(self, message_id, reaction, user_id):
         """
@@ -48,7 +48,7 @@ def send_reaction(self, message_id, reaction, user_id):
         :return: the Server Response
         """
         payload = {"reaction": add_user_id(reaction, user_id)}
-        return self.client.post(f"messages/{message_id}/reaction", data=payload)
+        return self.client.post("messages/{}/reaction".format(message_id), data=payload)
 
     def delete_reaction(self, message_id, reaction_type, user_id):
         """
@@ -60,7 +60,7 @@ def delete_reaction(self, message_id, reaction_type, user_id):
         :return: the Server Response
         """
         return self.client.delete(
-            f"messages/{message_id}/reaction/{reaction_type}",
+            "messages/{}/reaction/{}".format(message_id, reaction_type),
             params={"user_id": user_id},
         )
 
@@ -84,11 +84,11 @@ def query(self, **options):
         payload = {"state": True, "data": self.custom_data}
         payload.update(options)
 
-        url = f"channels/{self.channel_type}"
+        url = "channels/{}".format(self.channel_type)
         if self.id is not None:
-            url = f"{url}/{self.id}"
+            url = "{}/{}".format(url, self.id)
 
-        state = self.client.post(f"{url}/query", data=payload)
+        state = self.client.post("{}/query".format(url), data=payload)
 
         if self.id is None:
             self.id = state["channel"]["id"]
@@ -120,7 +120,7 @@ def truncate(self):
 
         :return: The server response
         """
-        return self.client.post(f"{self.url}/truncate")
+        return self.client.post("{}/truncate".format(self.url))
 
     def add_members(self, user_ids):
         """
@@ -167,7 +167,7 @@ def mark_read(self, user_id, **data):
         :return: The server response
         """
         payload = add_user_id(data, user_id)
-        return self.client.post(f"{self.url}/read", data=payload)
+        return self.client.post("{}/read".format(self.url), data=payload)
 
     def get_replies(self, parent_id, **options):
         """
@@ -177,17 +177,17 @@ def get_replies(self, parent_id, **options):
         :param options: Pagination params, ie {limit:10, idlte: 10}
         :return: A response with a list of messages
         """
-        return self.client.get(f"messages/{parent_id}/replies", params=options)
+        return self.client.get("messages/{}/replies".format(parent_id), params=options)
 
     def get_reactions(self, message_id, **options):
         """
         List the reactions, supports pagination
 
-        :param message_id: Tthe message id
+        :param message_id: The message id
         :param options: Pagination params, ie {"limit":10, "idlte": 10}
         :return: A response with a list of reactions
         """
-        return self.client.get(f"messages/{message_id}/reactions", params=options)
+        return self.client.get("messages/{}/reactions".format(message_id), params=options)
 
     def ban_user(self, user_id, **options):
         """

stream_chat/client.py

@@ -59,7 +59,7 @@ def _make_request(self, method, relative_url, params=None, data=None):
         headers["Authorization"] = self.auth_token
         headers["stream-auth-type"] = "jwt"
 
-        url = "%s/%s" % (self.base_url, relative_url)
+        url = "{}/{}".format(self.base_url, relative_url)
 
         if method.__name__ in ["post", "put", "patch"]:
             serialized = json.dumps(data)
@@ -107,13 +107,13 @@ def update_user(self, user):
         return self.update_users([user])
 
     def delete_user(self, user_id, **options):
-        return self.delete(f"users/{user_id}", options)
+        return self.delete("users/{}".format(user_id), options)
 
     def deactivate_user(self, user_id, **options):
-        return self.post(f"users/{user_id}/deactivate", options)
+        return self.post("users/{}/deactivate".format(user_id), options)
 
     def export_user(self, user_id, **options):
-        return self.get(f"users/{user_id}/export", options)
+        return self.get("users/{}/export".format(user_id), options)
 
     def ban_user(self, target_id, **options):
         data = dict(target_user_id=target_id)
@@ -154,10 +154,10 @@ def mark_all_read(self, user_id):
     def update_message(self, message):
         if message.get("id") is None:
             raise ValueError("message must have an id")
-        return self.post(f"messages/{message['id']}", data={"message": message})
+        return self.post("messages/{}".format(message['id']), data={"message": message})
 
     def delete_message(self, message_id):
-        return self.delete(f"messages/{message_id}")
+        return self.delete("messages/{}".format(message_id))
 
     def query_users(self, filter_conditions, sort=None, **options):
         sort_fields = []
@@ -182,13 +182,13 @@ def create_channel_type(self, data):
         return self.post("channeltypes", data=data)
 
     def get_channel_type(self, channel_type):
-        return self.get(f"channeltypes/{channel_type}")
+        return self.get("channeltypes/{}".format(channel_type))
 
     def list_channel_types(self):
         return self.get("channeltypes")
 
     def update_channel_type(self, channel_type, **settings):
-        return self.put(f"channeltypes/{channel_type}", **settings)
+        return self.put("channeltypes/{}".format(channel_type), **settings)
 
     def delete_channel_type(self, channel_type):
         """
@@ -197,7 +197,7 @@ def delete_channel_type(self, channel_type):
         :param channel_type: the channel type
         :return:
         """
-        return self.delete(f"channeltypes/{channel_type}")
+        return self.delete("channeltypes/{}".format(channel_type))
 
     def channel(self, channel_type, channel_id=None, data=None):
         """

stream_chat/exceptions.py

@@ -1,4 +1,3 @@
-import json
 from json import JSONDecodeError
 
 
@@ -23,6 +22,6 @@ def __init__(self, response):
 
     def __str__(self):
         if self.json_response:
-            return f"StreamChat error code {self.error_code}: {self.error_message}"
+            return "StreamChat error code {}: {}".format(self.error_code, self.error_message)
         else:
-            return f"StreamChat error HTTP code: {self.response.status_code}"
+            return "StreamChat error HTTP code: {}".format(self.response.status_code)

stream_chat/tests/test_client.py

@@ -1,6 +1,8 @@
 import jwt
 import pytest
 import uuid
+from stream_chat import StreamChat
+from stream_chat.exceptions import StreamAPIException
 
 
 @pytest.mark.incremental
@@ -12,6 +14,11 @@ def test_mute_user(self, client, random_users):
         assert response["mute"]["user"]["id"] == random_users[1]["id"]
         client.unmute_user(random_users[0]["id"], random_users[1]["id"])
 
+    def test_auth_exception(self):
+        client = StreamChat(api_key="bad", api_secret="guy")
+        with pytest.raises(StreamAPIException):
+            client.get_channel_type("team")
+
     def test_get_channel_types(self, client):
         response = client.get_channel_type("team")
         assert "permissions" in response