lint

resolvers/inbox/chats.py

@@ -1,13 +1,13 @@
-import json
-import uuid
-from datetime import datetime, timezone
-
 from auth.authenticate import login_required
 from auth.credentials import AuthCredentials
 from base.redis import redis
 from base.resolvers import mutation
+from datetime import datetime, timezone
 from validations.inbox import Chat
 
+import json
+import uuid
+
 
 @mutation.field("updateChat")
 @login_required
@@ -49,7 +49,7 @@ async def update_chat(_, info, chat_new: Chat):
 async def create_chat(_, info, title="", members=[]):
     auth: AuthCredentials = info.context["request"].auth
     chat = {}
-    print('create_chat members: %r' % members)
+    print("create_chat members: %r" % members)
     if auth.user_id not in members:
         members.append(int(auth.user_id))
 
@@ -71,8 +71,8 @@ async def create_chat(_, info, title="", members=[]):
             chat = await redis.execute("GET", f"chats/{c.decode('utf-8')}")
             if chat:
                 chat = json.loads(chat)
-                if chat['title'] == "":
-                    print('[inbox] createChat found old chat')
+                if chat["title"] == "":
+                    print("[inbox] createChat found old chat")
                     print(chat)
                     break
         if chat:
@@ -105,7 +105,7 @@ async def delete_chat(_, info, chat_id: str):
     chat = await redis.execute("GET", f"/chats/{chat_id}")
     if chat:
         chat = dict(json.loads(chat))
-        if auth.user_id in chat['admins']:
+        if auth.user_id in chat["admins"]:
             await redis.execute("DEL", f"chats/{chat_id}")
             await redis.execute("SREM", "chats_by_user/" + str(auth.user_id), chat_id)
             await redis.execute("COMMIT")

resolvers/inbox/load.py

@@ -1,5 +1,4 @@
-import json
-
+from .unread import get_unread_counter
 from auth.authenticate import login_required
 from auth.credentials import AuthCredentials
 from base.orm import local_session
@@ -8,13 +7,13 @@ from base.resolvers import query
 from orm.user import User
 from resolvers.zine.profile import followed_authors
 
-from .unread import get_unread_counter
+import json
 
 # from datetime import datetime, timedelta, timezone
 
 
 async def load_messages(chat_id: str, limit: int = 5, offset: int = 0, ids=[]):
-    '''load :limit messages for :chat_id with :offset'''
+    """load :limit messages for :chat_id with :offset"""
     messages = []
     message_ids = []
     if ids:
@@ -29,10 +28,10 @@ async def load_messages(chat_id: str, limit: int = 5, offset: int = 0, ids=[]):
     if message_ids:
         message_keys = [f"chats/{chat_id}/messages/{mid}" for mid in message_ids]
         messages = await redis.mget(*message_keys)
-        messages = [json.loads(msg.decode('utf-8')) for msg in messages]
+        messages = [json.loads(msg.decode("utf-8")) for msg in messages]
         replies = []
         for m in messages:
-            rt = m.get('replyTo')
+            rt = m.get("replyTo")
             if rt:
                 rt = int(rt)
                 if rt not in message_ids:
@@ -52,7 +51,7 @@ async def load_chats(_, info, limit: int = 50, offset: int = 0):
     if cids:
         cids = list(cids)[offset : offset + limit]
     if not cids:
-        print('[inbox.load] no chats were found')
+        print("[inbox.load] no chats were found")
         cids = []
     onliners = await redis.execute("SMEMBERS", "users-online")
     if not onliners:
@@ -63,14 +62,14 @@ async def load_chats(_, info, limit: int = 50, offset: int = 0):
         c = await redis.execute("GET", "chats/" + cid)
         if c:
             c = dict(json.loads(c))
-            c['messages'] = await load_messages(cid, 5, 0)
-            c['unread'] = await get_unread_counter(cid, auth.user_id)
+            c["messages"] = await load_messages(cid, 5, 0)
+            c["unread"] = await get_unread_counter(cid, auth.user_id)
             with local_session() as session:
-                c['members'] = []
+                c["members"] = []
                 for uid in c["users"]:
                     a = session.query(User).where(User.id == uid).first()
                     if a:
-                        c['members'].append(
+                        c["members"].append(
                             {
                                 "id": a.id,
                                 "slug": a.slug,
@@ -87,16 +86,16 @@ async def load_chats(_, info, limit: int = 50, offset: int = 0):
 @query.field("loadMessagesBy")
 @login_required
 async def load_messages_by(_, info, by, limit: int = 10, offset: int = 0):
-    '''load :limit messages of :chat_id with :offset'''
+    """load :limit messages of :chat_id with :offset"""
 
     auth: AuthCredentials = info.context["request"].auth
     userchats = await redis.execute("SMEMBERS", "chats_by_user/" + str(auth.user_id))
-    userchats = [c.decode('utf-8') for c in userchats]
+    userchats = [c.decode("utf-8") for c in userchats]
     # print('[inbox] userchats: %r' % userchats)
     if userchats:
         # print('[inbox] loading messages by...')
         messages = []
-        by_chat = by.get('chat')
+        by_chat = by.get("chat")
         if by_chat in userchats:
             chat = await redis.execute("GET", f"chats/{by_chat}")
             # print(chat)
@@ -104,7 +103,10 @@ async def load_messages_by(_, info, by, limit: int = 10, offset: int = 0):
                 return {"messages": [], "error": "chat not exist"}
             # everyone's messages in filtered chat
             messages = await load_messages(by_chat, limit, offset)
-        return {"messages": sorted(list(messages), key=lambda m: m['createdAt']), "error": None}
+        return {
+            "messages": sorted(list(messages), key=lambda m: m["createdAt"]),
+            "error": None,
+        }
     else:
         return {"error": "Cannot access messages of this chat"}
 

resolvers/inbox/messages.py

@@ -1,16 +1,11 @@
-import asyncio
-import json
-from datetime import datetime, timezone
-from typing import Any
-
-from graphql.type import GraphQLResolveInfo
-
 from auth.authenticate import login_required
 from auth.credentials import AuthCredentials
 from base.redis import redis
 from base.resolvers import mutation
-from services.following import Following, FollowingManager, FollowingResult
-from validations.inbox import Message
+from datetime import datetime, timezone
+from services.following import FollowingManager, FollowingResult
+
+import json
 
 
 @mutation.field("createMessage")
@@ -27,15 +22,15 @@ async def create_message(_, info, chat: str, body: str, replyTo=None):
         message_id = await redis.execute("GET", f"chats/{chat['id']}/next_message_id")
         message_id = int(message_id)
         new_message = {
-            "chatId": chat['id'],
+            "chatId": chat["id"],
             "id": message_id,
             "author": auth.user_id,
             "body": body,
             "createdAt": int(datetime.now(tz=timezone.utc).timestamp()),
         }
         if replyTo:
-            new_message['replyTo'] = replyTo
-        chat['updatedAt'] = new_message['createdAt']
+            new_message["replyTo"] = replyTo
+        chat["updatedAt"] = new_message["createdAt"]
         await redis.execute("SET", f"chats/{chat['id']}", json.dumps(chat))
         print(f"[inbox] creating message {new_message}")
         await redis.execute(
@@ -48,8 +43,8 @@ async def create_message(_, info, chat: str, body: str, replyTo=None):
         for user_slug in users:
             await redis.execute("LPUSH", f"chats/{chat['id']}/unread/{user_slug}", str(message_id))
 
-        result = FollowingResult("NEW", 'chat', new_message)
-        await FollowingManager.push('chat', result)
+        result = FollowingResult("NEW", "chat", new_message)
+        await FollowingManager.push("chat", result)
 
         return {"message": new_message, "error": None}
 
@@ -76,8 +71,8 @@ async def update_message(_, info, chat_id: str, message_id: int, body: str):
 
     await redis.execute("SET", f"chats/{chat_id}/messages/{message_id}", json.dumps(message))
 
-    result = FollowingResult("UPDATED", 'chat', message)
-    await FollowingManager.push('chat', result)
+    result = FollowingResult("UPDATED", "chat", message)
+    await FollowingManager.push("chat", result)
 
     return {"message": message, "error": None}
 
@@ -106,7 +101,7 @@ async def delete_message(_, info, chat_id: str, message_id: int):
     for user_id in users:
         await redis.execute("LREM", f"chats/{chat_id}/unread/{user_id}", 0, str(message_id))
 
-    result = FollowingResult("DELETED", 'chat', message)
+    result = FollowingResult("DELETED", "chat", message)
     await FollowingManager.push(result)
 
     return {}

resolvers/inbox/search.py

@@ -1,14 +1,14 @@
-import json
-from datetime import datetime, timedelta, timezone
-
 from auth.authenticate import login_required
 from auth.credentials import AuthCredentials
 from base.orm import local_session
 from base.redis import redis
 from base.resolvers import query
+from datetime import datetime, timedelta, timezone
 from orm.user import AuthorFollower, User
 from resolvers.inbox.load import load_messages
 
+import json
+
 
 @query.field("searchRecipients")
 @login_required
@@ -59,22 +59,22 @@ async def search_user_chats(by, messages, user_id: int, limit, offset):
     cids.union(set(await redis.execute("SMEMBERS", "chats_by_user/" + str(user_id))))
     messages = []
 
-    by_author = by.get('author')
+    by_author = by.get("author")
     if by_author:
         # all author's messages
         cids.union(set(await redis.execute("SMEMBERS", f"chats_by_user/{by_author}")))
         # author's messages in filtered chat
         messages.union(set(filter(lambda m: m["author"] == by_author, list(messages))))
         for c in cids:
-            c = c.decode('utf-8')
+            c = c.decode("utf-8")
             messages = await load_messages(c, limit, offset)
 
-    body_like = by.get('body')
+    body_like = by.get("body")
     if body_like:
         # search in all messages in all user's chats
         for c in cids:
             # FIXME: use redis scan here
-            c = c.decode('utf-8')
+            c = c.decode("utf-8")
             mmm = await load_messages(c, limit, offset)
             for m in mmm:
                 if body_like in m["body"]: