fmt

resolvers/reader.py

@@ -18,22 +18,22 @@ from services.logger import root_logger as logger
 
 
 def apply_filters(q, filters, author_id=None):
-    if filters.get('reacted') and author_id:
+    if filters.get("reacted") and author_id:
         q.join(Reaction, Reaction.created_by == author_id)
 
-    by_featured = filters.get('featured')
+    by_featured = filters.get("featured")
     if by_featured:
         q = q.filter(Shout.featured_at.is_not(None))
-    by_layouts = filters.get('layouts')
+    by_layouts = filters.get("layouts")
     if by_layouts:
         q = q.filter(Shout.layout.in_(by_layouts))
-    by_author = filters.get('author')
+    by_author = filters.get("author")
     if by_author:
         q = q.filter(Shout.authors.any(slug=by_author))
-    by_topic = filters.get('topic')
+    by_topic = filters.get("topic")
     if by_topic:
         q = q.filter(Shout.topics.any(slug=by_topic))
-    by_after = filters.get('after')
+    by_after = filters.get("after")
     if by_after:
         ts = int(by_after)
         q = q.filter(Shout.created_at > ts)
@@ -41,7 +41,7 @@ def apply_filters(q, filters, author_id=None):
     return q
 
 
-@query.field('get_shout')
+@query.field("get_shout")
 async def get_shout(_, _info, slug=None, shout_id=None):
     with local_session() as session:
         q = select(Shout).options(
@@ -72,13 +72,15 @@ async def get_shout(_, _info, slug=None, shout_id=None):
                 ] = results
 
                 shout.stat = {
-                    'viewed': await ViewedStorage.get_shout(shout.slug),
-                    'reacted': reacted_stat,
-                    'commented': commented_stat,
-                    'rating': int(likes_stat or 0) - int(dislikes_stat or 0),
+                    "viewed": await ViewedStorage.get_shout(shout.slug),
+                    "reacted": reacted_stat,
+                    "commented": commented_stat,
+                    "rating": int(likes_stat or 0) - int(dislikes_stat or 0),
                 }
 
-                for author_caption in session.query(ShoutAuthor).join(Shout).where(Shout.slug == slug):
+                for author_caption in (
+                    session.query(ShoutAuthor).join(Shout).where(Shout.slug == slug)
+                ):
                     for author in shout.authors:
                         if author.id == author_caption.author:
                             author.caption = author_caption.caption
@@ -99,10 +101,12 @@ async def get_shout(_, _info, slug=None, shout_id=None):
                     shout.main_topic = main_topic[0]
                 return shout
         except Exception:
-            raise HTTPException(status_code=404, detail=f'shout {slug or shout_id} not found')
+            raise HTTPException(
+                status_code=404, detail=f"shout {slug or shout_id} not found"
+            )
 
 
-@query.field('load_shouts_by')
+@query.field("load_shouts_by")
 async def load_shouts_by(_, _info, options):
     """
     :param options: {
@@ -138,20 +142,24 @@ async def load_shouts_by(_, _info, options):
     q = add_stat_columns(q, aliased_reaction)
 
     # filters
-    filters = options.get('filters', {})
+    filters = options.get("filters", {})
     q = apply_filters(q, filters)
 
     # group
     q = q.group_by(Shout.id)
 
     # order
-    order_by = options.get('order_by', Shout.featured_at if filters.get('featured') else Shout.published_at)
-    query_order_by = desc(order_by) if options.get('order_by_desc', True) else asc(order_by)
+    order_by = options.get(
+        "order_by", Shout.featured_at if filters.get("featured") else Shout.published_at
+    )
+    query_order_by = (
+        desc(order_by) if options.get("order_by_desc", True) else asc(order_by)
+    )
     q = q.order_by(nulls_last(query_order_by))
 
     # limit offset
-    offset = options.get('offset', 0)
-    limit = options.get('limit', 10)
+    offset = options.get("offset", 0)
+    limit = options.get("limit", 10)
     q = q.limit(limit).offset(offset)
 
     shouts = []
@@ -180,20 +188,20 @@ async def load_shouts_by(_, _info, options):
             if main_topic:
                 shout.main_topic = main_topic[0]
             shout.stat = {
-                'viewed': await ViewedStorage.get_shout(shout.slug),
-                'reacted': reacted_stat,
-                'commented': commented_stat,
-                'rating': int(likes_stat) - int(dislikes_stat),
+                "viewed": await ViewedStorage.get_shout(shout.slug),
+                "reacted": reacted_stat,
+                "commented": commented_stat,
+                "rating": int(likes_stat) - int(dislikes_stat),
             }
             shouts.append(shout)
 
     return shouts
 
 
-@query.field('load_shouts_drafts')
+@query.field("load_shouts_drafts")
 @login_required
 async def load_shouts_drafts(_, info):
-    user_id = info.context['user_id']
+    user_id = info.context["user_id"]
 
     q = (
         select(Shout)
@@ -231,24 +239,29 @@ async def load_shouts_drafts(_, info):
     return shouts
 
 
-@query.field('load_shouts_feed')
+@query.field("load_shouts_feed")
 @login_required
 async def load_shouts_feed(_, info, options):
-    user_id = info.context['user_id']
+    user_id = info.context["user_id"]
 
     shouts = []
     with local_session() as session:
         reader = session.query(Author).filter(Author.user == user_id).first()
         if reader:
-            reader_followed_authors = select(AuthorFollower.author).where(AuthorFollower.follower == reader.id)
-            reader_followed_topics = select(TopicFollower.topic).where(TopicFollower.follower == reader.id)
+            reader_followed_authors = select(AuthorFollower.author).where(
+                AuthorFollower.follower == reader.id
+            )
+            reader_followed_topics = select(TopicFollower.topic).where(
+                TopicFollower.follower == reader.id
+            )
 
             subquery = (
                 select(Shout.id)
                 .where(Shout.id == ShoutAuthor.shout)
                 .where(Shout.id == ShoutTopic.shout)
                 .where(
-                    (ShoutAuthor.author.in_(reader_followed_authors)) | (ShoutTopic.topic.in_(reader_followed_topics))
+                    (ShoutAuthor.author.in_(reader_followed_authors))
+                    | (ShoutTopic.topic.in_(reader_followed_topics))
                 )
             )
 
@@ -269,22 +282,37 @@ async def load_shouts_feed(_, info, options):
 
             aliased_reaction = aliased(Reaction)
             q = add_stat_columns(q, aliased_reaction)
-            filters = options.get('filters', {})
+            filters = options.get("filters", {})
             q = apply_filters(q, filters, reader.id)
 
-            order_by = options.get('order_by', Shout.featured_at if filters.get('featured') else Shout.published_at)
+            order_by = options.get(
+                "order_by",
+                Shout.featured_at if filters.get("featured") else Shout.published_at,
+            )
 
-            query_order_by = desc(order_by) if options.get('order_by_desc', True) else asc(order_by)
-            offset = options.get('offset', 0)
-            limit = options.get('limit', 10)
+            query_order_by = (
+                desc(order_by) if options.get("order_by_desc", True) else asc(order_by)
+            )
+            offset = options.get("offset", 0)
+            limit = options.get("limit", 10)
 
-            q = q.group_by(Shout.id).order_by(nulls_last(query_order_by)).limit(limit).offset(offset)
+            q = (
+                q.group_by(Shout.id)
+                .order_by(nulls_last(query_order_by))
+                .limit(limit)
+                .offset(offset)
+            )
 
             # print(q.compile(compile_kwargs={"literal_binds": True}))
 
-            for [shout, reacted_stat, commented_stat, likes_stat, dislikes_stat, _last_comment] in session.execute(
-                q
-            ).unique():
+            for [
+                shout,
+                reacted_stat,
+                commented_stat,
+                likes_stat,
+                dislikes_stat,
+                _last_comment,
+            ] in session.execute(q).unique():
                 main_topic = (
                     session.query(Topic.slug)
                     .join(
@@ -301,17 +329,17 @@ async def load_shouts_feed(_, info, options):
                 if main_topic:
                     shout.main_topic = main_topic[0]
                 shout.stat = {
-                    'viewed': await ViewedStorage.get_shout(shout.slug),
-                    'reacted': reacted_stat,
-                    'commented': commented_stat,
-                    'rating': likes_stat - dislikes_stat,
+                    "viewed": await ViewedStorage.get_shout(shout.slug),
+                    "reacted": reacted_stat,
+                    "commented": commented_stat,
+                    "rating": likes_stat - dislikes_stat,
                 }
                 shouts.append(shout)
 
     return shouts
 
 
-@query.field('load_shouts_search')
+@query.field("load_shouts_search")
 async def load_shouts_search(_, _info, text, limit=50, offset=0):
     if isinstance(text, str) and len(text) > 2:
         results = await search_text(text, limit, offset)
@@ -321,7 +349,7 @@ async def load_shouts_search(_, _info, text, limit=50, offset=0):
 
 
 @login_required
-@query.field('load_shouts_unrated')
+@query.field("load_shouts_unrated")
 async def load_shouts_unrated(_, info, limit: int = 50, offset: int = 0):
     q = (
         select(Shout)
@@ -334,10 +362,12 @@ async def load_shouts_unrated(_, info, limit: int = 50, offset: int = 0):
             and_(
                 Reaction.shout == Shout.id,
                 Reaction.replyTo.is_(None),
-                Reaction.kind.in_([ReactionKind.LIKE.value, ReactionKind.DISLIKE.value]),
+                Reaction.kind.in_(
+                    [ReactionKind.LIKE.value, ReactionKind.DISLIKE.value]
+                ),
             ),
         )
-        .outerjoin(Author, Author.user == bindparam('user_id'))
+        .outerjoin(Author, Author.user == bindparam("user_id"))
         .where(
             and_(
                 Shout.deleted_at.is_(None),
@@ -354,7 +384,7 @@ async def load_shouts_unrated(_, info, limit: int = 50, offset: int = 0):
     q = add_stat_columns(q, aliased_reaction)
 
     q = q.group_by(Shout.id).order_by(func.random()).limit(limit).offset(offset)
-    user_id = info.context.get('user_id')
+    user_id = info.context.get("user_id")
     if user_id:
         with local_session() as session:
             author = session.query(Author).filter(Author.user == user_id).first()
@@ -374,20 +404,20 @@ async def get_shouts_from_query(q, author_id=None):
             likes_stat,
             dislikes_stat,
             last_comment,
-        ] in session.execute(q, {'author_id': author_id}).unique():
+        ] in session.execute(q, {"author_id": author_id}).unique():
             shouts.append(shout)
             shout.stat = {
-                'viewed': await ViewedStorage.get_shout(shout_slug=shout.slug),
-                'reacted': reacted_stat,
-                'commented': commented_stat,
-                'rating': int(likes_stat or 0) - int(dislikes_stat or 0),
-                'last_comment': last_comment,
+                "viewed": await ViewedStorage.get_shout(shout_slug=shout.slug),
+                "reacted": reacted_stat,
+                "commented": commented_stat,
+                "rating": int(likes_stat or 0) - int(dislikes_stat or 0),
+                "last_comment": last_comment,
             }
 
     return shouts
 
 
-@query.field('load_shouts_random_top')
+@query.field("load_shouts_random_top")
 async def load_shouts_random_top(_, _info, options):
     """
     :param _
@@ -406,9 +436,11 @@ async def load_shouts_random_top(_, _info, options):
 
     aliased_reaction = aliased(Reaction)
 
-    subquery = select(Shout.id).outerjoin(aliased_reaction).where(Shout.deleted_at.is_(None))
+    subquery = (
+        select(Shout.id).outerjoin(aliased_reaction).where(Shout.deleted_at.is_(None))
+    )
 
-    subquery = apply_filters(subquery, options.get('filters', {}))
+    subquery = apply_filters(subquery, options.get("filters", {}))
     subquery = subquery.group_by(Shout.id).order_by(
         desc(
             func.sum(
@@ -423,7 +455,7 @@ async def load_shouts_random_top(_, _info, options):
         )
     )
 
-    random_limit = options.get('random_limit')
+    random_limit = options.get("random_limit")
     if random_limit:
         subquery = subquery.limit(random_limit)
 
@@ -438,20 +470,24 @@ async def load_shouts_random_top(_, _info, options):
     aliased_reaction = aliased(Reaction)
     q = add_stat_columns(q, aliased_reaction)
 
-    limit = options.get('limit', 10)
+    limit = options.get("limit", 10)
     q = q.group_by(Shout.id).order_by(func.random()).limit(limit)
 
     return await get_shouts_from_query(q)
 
 
-@query.field('load_shouts_random_topic')
+@query.field("load_shouts_random_topic")
 async def load_shouts_random_topic(_, info, limit: int = 10):
     topic = get_random_topic()
     if topic:
         shouts = fetch_shouts_by_topic(topic, limit)
         if shouts:
-            return {'topic': topic, 'shouts': shouts}
-    return { 'error': 'failed to get random topic after few retries', shouts: [], topic: {} }
+            return {"topic": topic, "shouts": shouts}
+    return {
+        "error": "failed to get random topic after few retries",
+        shouts: [],
+        topic: {},
+    }
 
 
 def fetch_shouts_by_topic(topic, limit):