Revert "Feature/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
@@ -24,24 +24,27 @@ async def update_chat(_, info, chat_new: Chat):
     chat_id = chat_new["id"]
     chat = await redis.execute("GET", f"chats/{chat_id}")
     if not chat:
-        return {"error": "chat not exist"}
+        return {
+            "error": "chat not exist"
+        }
     chat = dict(json.loads(chat))
 
     # TODO
     if auth.user_id in chat["admins"]:
-        chat.update(
-            {
-                "title": chat_new.get("title", chat["title"]),
-                "description": chat_new.get("description", chat["description"]),
-                "updatedAt": int(datetime.now(tz=timezone.utc).timestamp()),
-                "admins": chat_new.get("admins", chat.get("admins") or []),
-                "users": chat_new.get("users", chat["users"]),
-            }
-        )
+        chat.update({
+            "title": chat_new.get("title", chat["title"]),
+            "description": chat_new.get("description", chat["description"]),
+            "updatedAt": int(datetime.now(tz=timezone.utc).timestamp()),
+            "admins": chat_new.get("admins", chat.get("admins") or []),
+            "users": chat_new.get("users", chat["users"])
+        })
     await redis.execute("SET", f"chats/{chat.id}", json.dumps(chat))
     await redis.execute("COMMIT")
 
-    return {"error": None, "chat": chat}
+    return {
+        "error": None,
+        "chat": chat
+    }
 
 
 @mutation.field("createChat")
@@ -49,7 +52,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,12 +74,15 @@ 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:
-            return {"chat": chat, "error": "existed"}
+            return {
+                "chat": chat,
+                "error": "existed"
+            }
 
     chat_id = str(uuid.uuid4())
     chat = {
@@ -86,7 +92,7 @@ async def create_chat(_, info, title="", members=[]):
         "createdBy": auth.user_id,
         "createdAt": int(datetime.now(tz=timezone.utc).timestamp()),
         "updatedAt": int(datetime.now(tz=timezone.utc).timestamp()),
-        "admins": members if (len(members) == 2 and title == "") else [],
+        "admins": members if (len(members) == 2 and title == "") else []
     }
 
     for m in members:
@@ -94,7 +100,10 @@ async def create_chat(_, info, title="", members=[]):
     await redis.execute("SET", f"chats/{chat_id}", json.dumps(chat))
     await redis.execute("SET", f"chats/{chat_id}/next_message_id", str(0))
     await redis.execute("COMMIT")
-    return {"error": None, "chat": chat}
+    return {
+        "error": None,
+        "chat": chat
+    }
 
 
 @mutation.field("deleteChat")
@@ -105,9 +114,11 @@ 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")
     else:
-        return {"error": "chat not exist"}
+        return {
+            "error": "chat not exist"
+        }

resolvers/inbox/load.py

@@ -1,26 +1,28 @@
-from .unread import get_unread_counter
+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.orm import local_session
 from base.resolvers import query
 from orm.user import User
 from resolvers.zine.profile import followed_authors
-
-import json
-
-# from datetime import datetime, timedelta, timezone
+from .unread import get_unread_counter
 
 
 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:
         message_ids += ids
     try:
         if limit:
-            mids = await redis.lrange(f"chats/{chat_id}/message_ids", offset, offset + limit)
+            mids = await redis.lrange(f"chats/{chat_id}/message_ids",
+                                      offset,
+                                      offset + limit
+                                      )
             mids = [mid.decode("utf-8") for mid in mids]
             message_ids += mids
     except Exception as e:
@@ -28,10 +30,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:
@@ -44,14 +46,14 @@ async def load_messages(chat_id: str, limit: int = 5, offset: int = 0, ids=[]):
 @query.field("loadChats")
 @login_required
 async def load_chats(_, info, limit: int = 50, offset: int = 0):
-    """load :limit chats of current user with :offset"""
+    """ load :limit chats of current user with :offset """
     auth: AuthCredentials = info.context["request"].auth
 
     cids = await redis.execute("SMEMBERS", "chats_by_user/" + str(auth.user_id))
     if cids:
-        cids = list(cids)[offset : offset + limit]
+        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:
@@ -62,53 +64,62 @@ 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(
-                            {
-                                "id": a.id,
-                                "slug": a.slug,
-                                "userpic": a.userpic,
-                                "name": a.name,
-                                "lastSeen": a.lastSeen,
-                                "online": a.id in onliners,
-                            }
-                        )
+                        c['members'].append({
+                            "id": a.id,
+                            "slug": a.slug,
+                            "userpic": a.userpic,
+                            "name": a.name,
+                            "lastSeen": a.lastSeen,
+                            "online": a.id in onliners
+                        })
                 chats.append(c)
-    return {"chats": chats, "error": None}
+    return {
+        "chats": chats,
+        "error": None
+    }
 
 
 @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)
             if not chat:
-                return {"messages": [], "error": "chat not exist"}
+                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,
+            "messages": sorted(
+                list(messages),
+                key=lambda m: m['createdAt']
+            ),
+            "error": None
         }
     else:
-        return {"error": "Cannot access messages of this chat"}
+        return {
+            "error": "Cannot access messages of this chat"
+        }
 
 
 @query.field("loadRecipients")
@@ -127,14 +138,15 @@ async def load_recipients(_, info, limit=50, offset=0):
         chat_users += session.query(User).where(User.emailConfirmed).limit(limit).offset(offset)
         members = []
         for a in chat_users:
-            members.append(
-                {
-                    "id": a.id,
-                    "slug": a.slug,
-                    "userpic": a.userpic,
-                    "name": a.name,
-                    "lastSeen": a.lastSeen,
-                    "online": a.id in onliners,
-                }
-            )
-    return {"members": members, "error": None}
+            members.append({
+                "id": a.id,
+                "slug": a.slug,
+                "userpic": a.userpic,
+                "name": a.name,
+                "lastSeen": a.lastSeen,
+                "online": a.id in onliners
+            })
+    return {
+        "members": members,
+        "error": None
+    }

resolvers/inbox/messages.py

@@ -1,36 +1,41 @@
+import asyncio
+import json
+from typing import Any
+from datetime import datetime, timezone
+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 datetime import datetime, timezone
-from services.following import FollowingManager, FollowingResult
-
-import json
+from services.following import FollowingManager, FollowingResult, Following
+from validations.inbox import Message
 
 
 @mutation.field("createMessage")
 @login_required
 async def create_message(_, info, chat: str, body: str, replyTo=None):
-    """create message with :body for :chat_id replying to :replyTo optionally"""
+    """ create message with :body for :chat_id replying to :replyTo optionally """
     auth: AuthCredentials = info.context["request"].auth
 
     chat = await redis.execute("GET", f"chats/{chat}")
     if not chat:
-        return {"error": "chat is not exist"}
+        return {
+            "error": "chat is not exist"
+        }
     else:
         chat = dict(json.loads(chat))
         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()),
+            "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(
@@ -41,12 +46,17 @@ async def create_message(_, info, chat: str, body: str, replyTo=None):
 
         users = chat["users"]
         for user_slug in users:
-            await redis.execute("LPUSH", f"chats/{chat['id']}/unread/{user_slug}", str(message_id))
+            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}
+        return {
+            "message": new_message,
+            "error": None
+        }
 
 
 @mutation.field("updateMessage")
@@ -71,10 +81,13 @@ 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}
+    return {
+        "message": message,
+        "error": None
+    }
 
 
 @mutation.field("deleteMessage")
@@ -101,7 +114,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 {}
@@ -124,4 +137,6 @@ async def mark_as_read(_, info, chat_id: str, messages: [int]):
     for message_id in messages:
         await redis.execute("LREM", f"chats/{chat_id}/unread/{auth.user_id}", 0, str(message_id))
 
-    return {"error": None}
+    return {
+        "error": None
+    }

resolvers/inbox/search.py

@@ -1,14 +1,13 @@
+import json
+from datetime import datetime, timezone, timedelta
 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 base.orm import local_session
 from orm.user import AuthorFollower, User
 from resolvers.inbox.load import load_messages
 
-import json
-
 
 @query.field("searchRecipients")
 @login_required
@@ -18,7 +17,7 @@ async def search_recipients(_, info, query: str, limit: int = 50, offset: int =
     auth: AuthCredentials = info.context["request"].auth
     talk_before = await redis.execute("GET", f"/chats_by_user/{auth.user_id}")
     if talk_before:
-        talk_before = list(json.loads(talk_before))[offset : offset + limit]
+        talk_before = list(json.loads(talk_before))[offset:offset + limit]
         for chat_id in talk_before:
             members = await redis.execute("GET", f"/chats/{chat_id}/users")
             if members:
@@ -32,24 +31,23 @@ async def search_recipients(_, info, query: str, limit: int = 50, offset: int =
 
     with local_session() as session:
         # followings
-        result += (
-            session.query(AuthorFollower.author)
-            .join(User, User.id == AuthorFollower.follower)
-            .where(User.slug.startswith(query))
-            .offset(offset + len(result))
-            .limit(more_amount)
-        )
+        result += session.query(AuthorFollower.author).join(
+            User, User.id == AuthorFollower.follower
+        ).where(
+            User.slug.startswith(query)
+        ).offset(offset + len(result)).limit(more_amount)
 
         more_amount = limit
         # followers
-        result += (
-            session.query(AuthorFollower.follower)
-            .join(User, User.id == AuthorFollower.author)
-            .where(User.slug.startswith(query))
-            .offset(offset + len(result))
-            .limit(offset + len(result) + limit)
-        )
-    return {"members": list(result), "error": None}
+        result += session.query(AuthorFollower.follower).join(
+            User, User.id == AuthorFollower.author
+        ).where(
+            User.slug.startswith(query)
+        ).offset(offset + len(result)).limit(offset + len(result) + limit)
+    return {
+        "members": list(result),
+        "error": None
+    }
 
 
 @query.field("searchMessages")
@@ -59,22 +57,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"]:
@@ -85,12 +83,13 @@ async def search_user_chats(by, messages, user_id: int, limit, offset):
 
     days = by.get("days")
     if days:
-        messages.extend(
-            filter(
-                list(messages),
-                key=lambda m: (
-                    datetime.now(tz=timezone.utc) - int(m["createdAt"]) < timedelta(days=by["days"])
-                ),
+        messages.extend(filter(
+            list(messages),
+            key=lambda m: (
+                datetime.now(tz=timezone.utc) - int(m["createdAt"]) < timedelta(days=by["days"])
             )
-        )
-    return {"messages": messages, "error": None}
+        ))
+    return {
+        "messages": messages,
+        "error": None
+    }