configured isort, black, flake8

resolvers/zine/following.py

@@ -1,41 +1,36 @@
-import asyncio
-from base.orm import local_session
-from base.resolvers import mutation
 from auth.authenticate import login_required
 from auth.credentials import AuthCredentials
+from base.resolvers import mutation
+
 # from resolvers.community import community_follow, community_unfollow
-from orm.user import AuthorFollower
-from orm.topic import TopicFollower
-from orm.shout import ShoutReactionsFollower
 from resolvers.zine.profile import author_follow, author_unfollow
 from resolvers.zine.reactions import reactions_follow, reactions_unfollow
 from resolvers.zine.topics import topic_follow, topic_unfollow
-from services.following import Following, FollowingManager, FollowingResult
-from graphql.type import GraphQLResolveInfo
+from services.following import FollowingManager, FollowingResult
 
 
 @mutation.field("follow")
 @login_required
-async def follow(_, info, what, slug):
+async def follow(_, info, what, slug):  # noqa: C901
     auth: AuthCredentials = info.context["request"].auth
 
     try:
         if what == "AUTHOR":
             if author_follow(auth.user_id, slug):
-                result = FollowingResult("NEW", 'author', slug)
-                await FollowingManager.push('author', result)
+                result = FollowingResult("NEW", "author", slug)
+                await FollowingManager.push("author", result)
         elif what == "TOPIC":
             if topic_follow(auth.user_id, slug):
-                result = FollowingResult("NEW", 'topic', slug)
-                await FollowingManager.push('topic', result)
+                result = FollowingResult("NEW", "topic", slug)
+                await FollowingManager.push("topic", result)
         elif what == "COMMUNITY":
             if False:  # TODO: use community_follow(auth.user_id, slug):
-                result = FollowingResult("NEW", 'community', slug)
-                await FollowingManager.push('community', result)
+                result = FollowingResult("NEW", "community", slug)
+                await FollowingManager.push("community", result)
         elif what == "REACTIONS":
             if reactions_follow(auth.user_id, slug):
-                result = FollowingResult("NEW", 'shout', slug)
-                await FollowingManager.push('shout', result)
+                result = FollowingResult("NEW", "shout", slug)
+                await FollowingManager.push("shout", result)
     except Exception as e:
         print(Exception(e))
         return {"error": str(e)}
@@ -45,26 +40,26 @@ async def follow(_, info, what, slug):
 
 @mutation.field("unfollow")
 @login_required
-async def unfollow(_, info, what, slug):
+async def unfollow(_, info, what, slug):  # noqa: C901
     auth: AuthCredentials = info.context["request"].auth
 
     try:
         if what == "AUTHOR":
             if author_unfollow(auth.user_id, slug):
-                result = FollowingResult("DELETED", 'author', slug)
-                await FollowingManager.push('author', result)
+                result = FollowingResult("DELETED", "author", slug)
+                await FollowingManager.push("author", result)
         elif what == "TOPIC":
             if topic_unfollow(auth.user_id, slug):
-                result = FollowingResult("DELETED", 'topic', slug)
-                await FollowingManager.push('topic', result)
+                result = FollowingResult("DELETED", "topic", slug)
+                await FollowingManager.push("topic", result)
         elif what == "COMMUNITY":
             if False:  # TODO: use community_unfollow(auth.user_id, slug):
-                result = FollowingResult("DELETED", 'community', slug)
-                await FollowingManager.push('community', result)
+                result = FollowingResult("DELETED", "community", slug)
+                await FollowingManager.push("community", result)
         elif what == "REACTIONS":
             if reactions_unfollow(auth.user_id, slug):
-                result = FollowingResult("DELETED", 'shout', slug)
-                await FollowingManager.push('shout', result)
+                result = FollowingResult("DELETED", "shout", slug)
+                await FollowingManager.push("shout", result)
     except Exception as e:
         return {"error": str(e)}
 

resolvers/zine/load.py

@@ -1,11 +1,11 @@
 from datetime import datetime, timedelta, timezone
 
-from sqlalchemy.orm import joinedload, aliased
-from sqlalchemy.sql.expression import desc, asc, select, func, case, and_, text, nulls_last
+from sqlalchemy.orm import aliased, joinedload
+from sqlalchemy.sql.expression import and_, asc, case, desc, func, nulls_last, select
 
 from auth.authenticate import login_required
 from auth.credentials import AuthCredentials
-from base.exceptions import ObjectNotExist, OperationNotAllowed
+from base.exceptions import ObjectNotExist
 from base.orm import local_session
 from base.resolvers import query
 from orm import TopicFollower
@@ -18,37 +18,37 @@ def add_stat_columns(q):
     aliased_reaction = aliased(Reaction)
 
     q = q.outerjoin(aliased_reaction).add_columns(
-        func.sum(
-            aliased_reaction.id
-        ).label('reacted_stat'),
+        func.sum(aliased_reaction.id).label("reacted_stat"),
+        func.sum(case((aliased_reaction.kind == ReactionKind.COMMENT, 1), else_=0)).label(
+            "commented_stat"
+        ),
         func.sum(
             case(
-                (aliased_reaction.kind == ReactionKind.COMMENT, 1),
-                else_=0
+                # do not count comments' reactions
+                (aliased_reaction.replyTo.is_not(None), 0),
+                (aliased_reaction.kind == ReactionKind.AGREE, 1),
+                (aliased_reaction.kind == ReactionKind.DISAGREE, -1),
+                (aliased_reaction.kind == ReactionKind.PROOF, 1),
+                (aliased_reaction.kind == ReactionKind.DISPROOF, -1),
+                (aliased_reaction.kind == ReactionKind.ACCEPT, 1),
+                (aliased_reaction.kind == ReactionKind.REJECT, -1),
+                (aliased_reaction.kind == ReactionKind.LIKE, 1),
+                (aliased_reaction.kind == ReactionKind.DISLIKE, -1),
+                else_=0,
             )
-        ).label('commented_stat'),
-        func.sum(case(
-            # do not count comments' reactions
-            (aliased_reaction.replyTo.is_not(None), 0),
-            (aliased_reaction.kind == ReactionKind.AGREE, 1),
-            (aliased_reaction.kind == ReactionKind.DISAGREE, -1),
-            (aliased_reaction.kind == ReactionKind.PROOF, 1),
-            (aliased_reaction.kind == ReactionKind.DISPROOF, -1),
-            (aliased_reaction.kind == ReactionKind.ACCEPT, 1),
-            (aliased_reaction.kind == ReactionKind.REJECT, -1),
-            (aliased_reaction.kind == ReactionKind.LIKE, 1),
-            (aliased_reaction.kind == ReactionKind.DISLIKE, -1),
-            else_=0)
-        ).label('rating_stat'),
-        func.max(case(
-            (aliased_reaction.kind != ReactionKind.COMMENT, None),
-            else_=aliased_reaction.createdAt
-        )).label('last_comment'))
+        ).label("rating_stat"),
+        func.max(
+            case(
+                (aliased_reaction.kind != ReactionKind.COMMENT, None),
+                else_=aliased_reaction.createdAt,
+            )
+        ).label("last_comment"),
+    )
 
     return q
 
 
-def apply_filters(q, filters, user_id=None):
+def apply_filters(q, filters, user_id=None):  # noqa: C901
     if filters.get("reacted") and user_id:
         q.join(Reaction, Reaction.createdBy == user_id)
 
@@ -60,7 +60,7 @@ def apply_filters(q, filters, user_id=None):
 
     if filters.get("layout"):
         q = q.filter(Shout.layout == filters.get("layout"))
-    if filters.get('excludeLayout'):
+    if filters.get("excludeLayout"):
         q = q.filter(Shout.layout != filters.get("excludeLayout"))
     if filters.get("author"):
         q = q.filter(Shout.authors.any(slug=filters.get("author")))
@@ -87,27 +87,23 @@ async def load_shout(_, info, slug=None, shout_id=None):
         q = add_stat_columns(q)
 
         if slug is not None:
-            q = q.filter(
-                Shout.slug == slug
-            )
+            q = q.filter(Shout.slug == slug)
 
         if shout_id is not None:
-            q = q.filter(
-                Shout.id == shout_id
-            )
+            q = q.filter(Shout.id == shout_id)
 
-        q = q.filter(
-            Shout.deletedAt.is_(None)
-        ).group_by(Shout.id)
+        q = q.filter(Shout.deletedAt.is_(None)).group_by(Shout.id)
 
         try:
-            [shout, reacted_stat, commented_stat, rating_stat, last_comment] = session.execute(q).first()
+            [shout, reacted_stat, commented_stat, rating_stat, last_comment] = session.execute(
+                q
+            ).first()
 
             shout.stat = {
                 "viewed": shout.views,
                 "reacted": reacted_stat,
                 "commented": commented_stat,
-                "rating": rating_stat
+                "rating": rating_stat,
             }
 
             for author_caption in session.query(ShoutAuthor).join(Shout).where(Shout.slug == slug):
@@ -142,14 +138,13 @@ async def load_shouts_by(_, info, options):
     :return: Shout[]
     """
 
-    q = select(Shout).options(
-        joinedload(Shout.authors),
-        joinedload(Shout.topics),
-    ).where(
-        and_(
-            Shout.deletedAt.is_(None),
-            Shout.layout.is_not(None)
+    q = (
+        select(Shout)
+        .options(
+            joinedload(Shout.authors),
+            joinedload(Shout.topics),
         )
+        .where(and_(Shout.deletedAt.is_(None), Shout.layout.is_not(None)))
     )
 
     q = add_stat_columns(q)
@@ -159,7 +154,7 @@ async def load_shouts_by(_, info, options):
 
     order_by = options.get("order_by", Shout.publishedAt)
 
-    query_order_by = desc(order_by) if options.get('order_by_desc', True) else asc(order_by)
+    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)
 
@@ -169,13 +164,15 @@ async def load_shouts_by(_, info, options):
     with local_session() as session:
         shouts_map = {}
 
-        for [shout, reacted_stat, commented_stat, rating_stat, last_comment] in session.execute(q).unique():
+        for [shout, reacted_stat, commented_stat, rating_stat, last_comment] in session.execute(
+            q
+        ).unique():
             shouts.append(shout)
             shout.stat = {
                 "viewed": shout.views,
                 "reacted": reacted_stat,
                 "commented": commented_stat,
-                "rating": rating_stat
+                "rating": rating_stat,
             }
             shouts_map[shout.id] = shout
 
@@ -188,11 +185,13 @@ async def get_drafts(_, info):
     auth: AuthCredentials = info.context["request"].auth
     user_id = auth.user_id
 
-    q = select(Shout).options(
-        joinedload(Shout.authors),
-        joinedload(Shout.topics),
-    ).where(
-        and_(Shout.deletedAt.is_(None), Shout.createdBy == user_id)
+    q = (
+        select(Shout)
+        .options(
+            joinedload(Shout.authors),
+            joinedload(Shout.topics),
+        )
+        .where(and_(Shout.deletedAt.is_(None), Shout.createdBy == user_id))
     )
 
     q = q.group_by(Shout.id)
@@ -211,24 +210,22 @@ async def get_my_feed(_, info, options):
     auth: AuthCredentials = info.context["request"].auth
     user_id = auth.user_id
 
-    subquery = select(Shout.id).join(
-        ShoutAuthor
-    ).join(
-        AuthorFollower, AuthorFollower.follower == user_id
-    ).join(
-        ShoutTopic
-    ).join(
-        TopicFollower, TopicFollower.follower == user_id
+    subquery = (
+        select(Shout.id)
+        .join(ShoutAuthor)
+        .join(AuthorFollower, AuthorFollower.follower == user_id)
+        .join(ShoutTopic)
+        .join(TopicFollower, TopicFollower.follower == user_id)
     )
 
-    q = select(Shout).options(
-        joinedload(Shout.authors),
-        joinedload(Shout.topics),
-    ).where(
-        and_(
-            Shout.publishedAt.is_not(None),
-            Shout.deletedAt.is_(None),
-            Shout.id.in_(subquery)
+    q = (
+        select(Shout)
+        .options(
+            joinedload(Shout.authors),
+            joinedload(Shout.topics),
+        )
+        .where(
+            and_(Shout.publishedAt.is_not(None), Shout.deletedAt.is_(None), Shout.id.in_(subquery))
         )
     )
 
@@ -237,7 +234,7 @@ async def get_my_feed(_, info, options):
 
     order_by = options.get("order_by", Shout.publishedAt)
 
-    query_order_by = desc(order_by) if options.get('order_by_desc', True) else asc(order_by)
+    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)
 
@@ -246,13 +243,15 @@ async def get_my_feed(_, info, options):
     shouts = []
     with local_session() as session:
         shouts_map = {}
-        for [shout, reacted_stat, commented_stat, rating_stat, last_comment] in session.execute(q).unique():
+        for [shout, reacted_stat, commented_stat, rating_stat, last_comment] in session.execute(
+            q
+        ).unique():
             shouts.append(shout)
             shout.stat = {
                 "viewed": shout.views,
                 "reacted": reacted_stat,
                 "commented": commented_stat,
-                "rating": rating_stat
+                "rating": rating_stat,
             }
             shouts_map[shout.id] = shout
 

resolvers/zine/profile.py

@@ -1,6 +1,7 @@
-from typing import List
 from datetime import datetime, timedelta, timezone
-from sqlalchemy import and_, func, distinct, select, literal
+from typing import List
+
+from sqlalchemy import and_, distinct, func, literal, select
 from sqlalchemy.orm import aliased, joinedload
 
 from auth.authenticate import login_required
@@ -21,27 +22,27 @@ def add_author_stat_columns(q):
     # user_rating_aliased = aliased(UserRating)
 
     q = q.outerjoin(shout_author_aliased).add_columns(
-        func.count(distinct(shout_author_aliased.shout)).label('shouts_stat')
+        func.count(distinct(shout_author_aliased.shout)).label("shouts_stat")
     )
     q = q.outerjoin(author_followers, author_followers.author == User.id).add_columns(
-        func.count(distinct(author_followers.follower)).label('followers_stat')
+        func.count(distinct(author_followers.follower)).label("followers_stat")
     )
 
     q = q.outerjoin(author_following, author_following.follower == User.id).add_columns(
-        func.count(distinct(author_following.author)).label('followings_stat')
+        func.count(distinct(author_following.author)).label("followings_stat")
     )
 
-    q = q.add_columns(literal(0).label('rating_stat'))
+    q = q.add_columns(literal(0).label("rating_stat"))
     # FIXME
     # q = q.outerjoin(user_rating_aliased, user_rating_aliased.user == User.id).add_columns(
     #     # TODO: check
     #     func.sum(user_rating_aliased.value).label('rating_stat')
     # )
 
-    q = q.add_columns(literal(0).label('commented_stat'))
-    # q = q.outerjoin(Reaction, and_(Reaction.createdBy == User.id, Reaction.body.is_not(None))).add_columns(
-    #     func.count(distinct(Reaction.id)).label('commented_stat')
-    # )
+    q = q.add_columns(literal(0).label("commented_stat"))
+    # q = q.outerjoin(
+    #     Reaction, and_(Reaction.createdBy == User.id, Reaction.body.is_not(None))
+    # ).add_columns(func.count(distinct(Reaction.id)).label("commented_stat"))
 
     q = q.group_by(User.id)
 
@@ -55,7 +56,7 @@ def add_stat(author, stat_columns):
         "followers": followers_stat,
         "followings": followings_stat,
         "rating": rating_stat,
-        "commented": commented_stat
+        "commented": commented_stat,
     }
 
     return author
@@ -119,10 +120,10 @@ async def user_followers(_, _info, slug) -> List[User]:
     q = add_author_stat_columns(q)
 
     aliased_user = aliased(User)
-    q = q.join(AuthorFollower, AuthorFollower.follower == User.id).join(
-        aliased_user, aliased_user.id == AuthorFollower.author
-    ).where(
-        aliased_user.slug == slug
+    q = (
+        q.join(AuthorFollower, AuthorFollower.follower == User.id)
+        .join(aliased_user, aliased_user.id == AuthorFollower.author)
+        .where(aliased_user.slug == slug)
     )
 
     return get_authors_from_query(q)
@@ -150,15 +151,10 @@ async def update_profile(_, info, profile):
     with local_session() as session:
         user = session.query(User).filter(User.id == user_id).one()
         if not user:
-            return {
-                "error": "canoot find user"
-            }
+            return {"error": "canoot find user"}
         user.update(profile)
         session.commit()
-    return {
-        "error": None,
-        "author": user
-    }
+    return {"error": None, "author": user}
 
 
 @mutation.field("rateUser")
@@ -192,7 +188,8 @@ def author_follow(user_id, slug):
             session.add(af)
             session.commit()
         return True
-    except:
+    except Exception as e:
+        print(e)
         return False
 
 
@@ -200,13 +197,10 @@ def author_follow(user_id, slug):
 def author_unfollow(user_id, slug):
     with local_session() as session:
         flw = (
-            session.query(
-                AuthorFollower
-            ).join(User, User.id == AuthorFollower.author).filter(
-                and_(
-                    AuthorFollower.follower == user_id, User.slug == slug
-                )
-            ).first()
+            session.query(AuthorFollower)
+            .join(User, User.id == AuthorFollower.author)
+            .filter(and_(AuthorFollower.follower == user_id, User.slug == slug))
+            .first()
         )
         if flw:
             session.delete(flw)
@@ -232,12 +226,11 @@ async def get_author(_, _info, slug):
     [author] = get_authors_from_query(q)
 
     with local_session() as session:
-        comments_count = session.query(Reaction).where(
-            and_(
-                Reaction.createdBy == author.id,
-                Reaction.kind == ReactionKind.COMMENT
-            )
-        ).count()
+        comments_count = (
+            session.query(Reaction)
+            .where(and_(Reaction.createdBy == author.id, Reaction.kind == ReactionKind.COMMENT))
+            .count()
+        )
         author.stat["commented"] = comments_count
 
     return author
@@ -260,9 +253,7 @@ async def load_authors_by(_, info, by, limit, offset):
         days_before = datetime.now(tz=timezone.utc) - timedelta(days=by["createdAt"])
         q = q.filter(User.createdAt > days_before)
 
-    q = q.order_by(
-        by.get("order", User.createdAt)
-    ).limit(limit).offset(offset)
+    q = q.order_by(by.get("order", User.createdAt)).limit(limit).offset(offset)
 
     return get_authors_from_query(q)
 
@@ -273,13 +264,13 @@ async def load_my_subscriptions(_, info):
     auth = info.context["request"].auth
     user_id = auth.user_id
 
-    authors_query = select(User).join(AuthorFollower, AuthorFollower.author == User.id).where(
-        AuthorFollower.follower == user_id
+    authors_query = (
+        select(User)
+        .join(AuthorFollower, AuthorFollower.author == User.id)
+        .where(AuthorFollower.follower == user_id)
     )
 
-    topics_query = select(Topic).join(TopicFollower).where(
-        TopicFollower.follower == user_id
-    )
+    topics_query = select(Topic).join(TopicFollower).where(TopicFollower.follower == user_id)
 
     topics = []
     authors = []
@@ -291,7 +282,4 @@ async def load_my_subscriptions(_, info):
         for [topic] in session.execute(topics_query):
             topics.append(topic)
 
-    return {
-        "topics": topics,
-        "authors": authors
-    }
+    return {"topics": topics, "authors": authors}

resolvers/zine/reactions.py

@@ -1,5 +1,6 @@
 from datetime import datetime, timedelta, timezone
-from sqlalchemy import and_, asc, desc, select, text, func, case
+
+from sqlalchemy import and_, asc, case, desc, func, select, text
 from sqlalchemy.orm import aliased
 
 from auth.authenticate import login_required
@@ -17,26 +18,22 @@ def add_reaction_stat_columns(q):
     aliased_reaction = aliased(Reaction)
 
     q = q.outerjoin(aliased_reaction, Reaction.id == aliased_reaction.replyTo).add_columns(
-        func.sum(
-            aliased_reaction.id
-        ).label('reacted_stat'),
+        func.sum(aliased_reaction.id).label("reacted_stat"),
+        func.sum(case((aliased_reaction.body.is_not(None), 1), else_=0)).label("commented_stat"),
         func.sum(
             case(
-                (aliased_reaction.body.is_not(None), 1),
-                else_=0
+                (aliased_reaction.kind == ReactionKind.AGREE, 1),
+                (aliased_reaction.kind == ReactionKind.DISAGREE, -1),
+                (aliased_reaction.kind == ReactionKind.PROOF, 1),
+                (aliased_reaction.kind == ReactionKind.DISPROOF, -1),
+                (aliased_reaction.kind == ReactionKind.ACCEPT, 1),
+                (aliased_reaction.kind == ReactionKind.REJECT, -1),
+                (aliased_reaction.kind == ReactionKind.LIKE, 1),
+                (aliased_reaction.kind == ReactionKind.DISLIKE, -1),
+                else_=0,
             )
-        ).label('commented_stat'),
-        func.sum(case(
-            (aliased_reaction.kind == ReactionKind.AGREE, 1),
-            (aliased_reaction.kind == ReactionKind.DISAGREE, -1),
-            (aliased_reaction.kind == ReactionKind.PROOF, 1),
-            (aliased_reaction.kind == ReactionKind.DISPROOF, -1),
-            (aliased_reaction.kind == ReactionKind.ACCEPT, 1),
-            (aliased_reaction.kind == ReactionKind.REJECT, -1),
-            (aliased_reaction.kind == ReactionKind.LIKE, 1),
-            (aliased_reaction.kind == ReactionKind.DISLIKE, -1),
-            else_=0)
-        ).label('rating_stat'))
+        ).label("rating_stat"),
+    )
 
     return q
 
@@ -47,22 +44,25 @@ def reactions_follow(user_id, shout_id: int, auto=False):
             shout = session.query(Shout).where(Shout.id == shout_id).one()
 
             following = (
-                session.query(ShoutReactionsFollower).where(and_(
-                    ShoutReactionsFollower.follower == user_id,
-                    ShoutReactionsFollower.shout == shout.id,
-                )).first()
+                session.query(ShoutReactionsFollower)
+                .where(
+                    and_(
+                        ShoutReactionsFollower.follower == user_id,
+                        ShoutReactionsFollower.shout == shout.id,
+                    )
+                )
+                .first()
             )
 
             if not following:
                 following = ShoutReactionsFollower.create(
-                    follower=user_id,
-                    shout=shout.id,
-                    auto=auto
+                    follower=user_id, shout=shout.id, auto=auto
                 )
                 session.add(following)
                 session.commit()
                 return True
-    except:
+    except Exception as e:
+        print(e)
         return False
 
 
@@ -72,46 +72,52 @@ def reactions_unfollow(user_id: int, shout_id: int):
             shout = session.query(Shout).where(Shout.id == shout_id).one()
 
             following = (
-                session.query(ShoutReactionsFollower).where(and_(
-                    ShoutReactionsFollower.follower == user_id,
-                    ShoutReactionsFollower.shout == shout.id
-                )).first()
+                session.query(ShoutReactionsFollower)
+                .where(
+                    and_(
+                        ShoutReactionsFollower.follower == user_id,
+                        ShoutReactionsFollower.shout == shout.id,
+                    )
+                )
+                .first()
             )
 
             if following:
                 session.delete(following)
                 session.commit()
                 return True
-    except:
+    except Exception as e:
+        print(e)
         pass
     return False
 
 
 def is_published_author(session, user_id):
-    ''' checks if user has at least one publication '''
-    return session.query(
-        Shout
-    ).where(
-        Shout.authors.contains(user_id)
-    ).filter(
-        and_(
-            Shout.publishedAt.is_not(None),
-            Shout.deletedAt.is_(None)
-        )
-    ).count() > 0
+    """checks if user has at least one publication"""
+    return (
+        session.query(Shout)
+        .where(Shout.authors.contains(user_id))
+        .filter(and_(Shout.publishedAt.is_not(None), Shout.deletedAt.is_(None)))
+        .count()
+        > 0
+    )
 
 
 def check_to_publish(session, user_id, reaction):
-    ''' set shout to public if publicated approvers amount > 4 '''
+    """set shout to public if publicated approvers amount > 4"""
     if not reaction.replyTo and reaction.kind in [
         ReactionKind.ACCEPT,
         ReactionKind.LIKE,
-        ReactionKind.PROOF
+        ReactionKind.PROOF,
     ]:
         if is_published_author(user_id):
             # now count how many approvers are voted already
-            approvers_reactions = session.query(Reaction).where(Reaction.shout == reaction.shout).all()
-            approvers = [user_id, ]
+            approvers_reactions = (
+                session.query(Reaction).where(Reaction.shout == reaction.shout).all()
+            )
+            approvers = [
+                user_id,
+            ]
             for ar in approvers_reactions:
                 a = ar.createdBy
                 if is_published_author(session, a):
@@ -122,21 +128,17 @@ def check_to_publish(session, user_id, reaction):
 
 
 def check_to_hide(session, user_id, reaction):
-    ''' hides any shout if 20% of reactions are negative '''
+    """hides any shout if 20% of reactions are negative"""
     if not reaction.replyTo and reaction.kind in [
         ReactionKind.REJECT,
         ReactionKind.DISLIKE,
-        ReactionKind.DISPROOF
+        ReactionKind.DISPROOF,
     ]:
         # if is_published_author(user):
         approvers_reactions = session.query(Reaction).where(Reaction.shout == reaction.shout).all()
         rejects = 0
         for r in approvers_reactions:
-            if r.kind in [
-                ReactionKind.REJECT,
-                ReactionKind.DISLIKE,
-                ReactionKind.DISPROOF
-            ]:
+            if r.kind in [ReactionKind.REJECT, ReactionKind.DISLIKE, ReactionKind.DISPROOF]:
                 rejects += 1
         if len(approvers_reactions) / rejects < 5:
             return True
@@ -146,14 +148,14 @@ def check_to_hide(session, user_id, reaction):
 def set_published(session, shout_id):
     s = session.query(Shout).where(Shout.id == shout_id).first()
     s.publishedAt = datetime.now(tz=timezone.utc)
-    s.visibility = text('public')
+    s.visibility = text("public")
     session.add(s)
     session.commit()
 
 
 def set_hidden(session, shout_id):
     s = session.query(Shout).where(Shout.id == shout_id).first()
-    s.visibility = text('community')
+    s.visibility = text("community")
     session.add(s)
     session.commit()
 
@@ -162,37 +164,46 @@ def set_hidden(session, shout_id):
 @login_required
 async def create_reaction(_, info, reaction):
     auth: AuthCredentials = info.context["request"].auth
-    reaction['createdBy'] = auth.user_id
+    reaction["createdBy"] = auth.user_id
     rdict = {}
     with local_session() as session:
         shout = session.query(Shout).where(Shout.id == reaction["shout"]).one()
         author = session.query(User).where(User.id == auth.user_id).one()
 
-        if reaction["kind"] in [
-            ReactionKind.DISLIKE.name,
-            ReactionKind.LIKE.name
-        ]:
-            existing_reaction = session.query(Reaction).where(
-                and_(
-                    Reaction.shout == reaction["shout"],
-                    Reaction.createdBy == auth.user_id,
-                    Reaction.kind == reaction["kind"],
-                    Reaction.replyTo == reaction.get("replyTo")
+        if reaction["kind"] in [ReactionKind.DISLIKE.name, ReactionKind.LIKE.name]:
+            existing_reaction = (
+                session.query(Reaction)
+                .where(
+                    and_(
+                        Reaction.shout == reaction["shout"],
+                        Reaction.createdBy == auth.user_id,
+                        Reaction.kind == reaction["kind"],
+                        Reaction.replyTo == reaction.get("replyTo"),
+                    )
                 )
-            ).first()
+                .first()
+            )
 
             if existing_reaction is not None:
                 raise OperationNotAllowed("You can't vote twice")
 
-            opposite_reaction_kind = ReactionKind.DISLIKE if reaction["kind"] == ReactionKind.LIKE.name else ReactionKind.LIKE
-            opposite_reaction = session.query(Reaction).where(
+            opposite_reaction_kind = (
+                ReactionKind.DISLIKE
+                if reaction["kind"] == ReactionKind.LIKE.name
+                else ReactionKind.LIKE
+            )
+            opposite_reaction = (
+                session.query(Reaction)
+                .where(
                     and_(
                         Reaction.shout == reaction["shout"],
                         Reaction.createdBy == auth.user_id,
                         Reaction.kind == opposite_reaction_kind,
-                        Reaction.replyTo == reaction.get("replyTo")
+                        Reaction.replyTo == reaction.get("replyTo"),
                     )
-                ).first()
+                )
+                .first()
+            )
 
             if opposite_reaction is not None:
                 session.delete(opposite_reaction)
@@ -221,8 +232,8 @@ async def create_reaction(_, info, reaction):
         await notification_service.handle_new_reaction(r.id)
 
         rdict = r.dict()
-        rdict['shout'] = shout.dict()
-        rdict['createdBy'] = author.dict()
+        rdict["shout"] = shout.dict()
+        rdict["createdBy"] = author.dict()
 
         # self-regulation mechanics
         if check_to_hide(session, auth.user_id, r):
@@ -235,11 +246,7 @@ async def create_reaction(_, info, reaction):
     except Exception as e:
         print(f"[resolvers.reactions] error on reactions autofollowing: {e}")
 
-    rdict['stat'] = {
-        "commented": 0,
-        "reacted": 0,
-        "rating": 0
-    }
+    rdict["stat"] = {"commented": 0, "reacted": 0, "rating": 0}
     return {"reaction": rdict}
 
 
@@ -269,11 +276,7 @@ async def update_reaction(_, info, id, reaction={}):
         if reaction.get("range"):
             r.range = reaction.get("range")
         session.commit()
-        r.stat = {
-            "commented": commented_stat,
-            "reacted": reacted_stat,
-            "rating": rating_stat
-        }
+        r.stat = {"commented": commented_stat, "reacted": reacted_stat, "rating": rating_stat}
 
     return {"reaction": r}
 
@@ -290,17 +293,12 @@ async def delete_reaction(_, info, id):
         if r.createdBy != auth.user_id:
             return {"error": "access denied"}
 
-        if r.kind in [
-            ReactionKind.LIKE,
-            ReactionKind.DISLIKE
-        ]:
+        if r.kind in [ReactionKind.LIKE, ReactionKind.DISLIKE]:
             session.delete(r)
         else:
             r.deletedAt = datetime.now(tz=timezone.utc)
         session.commit()
-        return {
-            "reaction": r
-        }
+        return {"reaction": r}
 
 
 @query.field("loadReactionsBy")
@@ -321,12 +319,10 @@ async def load_reactions_by(_, _info, by, limit=50, offset=0):
     :return: Reaction[]
     """
 
-    q = select(
-        Reaction, User, Shout
-    ).join(
-        User, Reaction.createdBy == User.id
-    ).join(
-        Shout, Reaction.shout == Shout.id
+    q = (
+        select(Reaction, User, Shout)
+        .join(User, Reaction.createdBy == User.id)
+        .join(Shout, Reaction.shout == Shout.id)
     )
 
     if by.get("shout"):
@@ -344,7 +340,7 @@ async def load_reactions_by(_, _info, by, limit=50, offset=0):
     if by.get("comment"):
         q = q.filter(func.length(Reaction.body) > 0)
 
-    if len(by.get('search', '')) > 2:
+    if len(by.get("search", "")) > 2:
         q = q.filter(Reaction.body.ilike(f'%{by["body"]}%'))
 
     if by.get("days"):
@@ -352,13 +348,9 @@ async def load_reactions_by(_, _info, by, limit=50, offset=0):
         q = q.filter(Reaction.createdAt > after)
 
     order_way = asc if by.get("sort", "").startswith("-") else desc
-    order_field = by.get("sort", "").replace('-', '') or Reaction.createdAt
+    order_field = by.get("sort", "").replace("-", "") or Reaction.createdAt
 
-    q = q.group_by(
-        Reaction.id, User.id, Shout.id
-    ).order_by(
-        order_way(order_field)
-    )
+    q = q.group_by(Reaction.id, User.id, Shout.id).order_by(order_way(order_field))
 
     q = add_reaction_stat_columns(q)
 
@@ -367,13 +359,15 @@ async def load_reactions_by(_, _info, by, limit=50, offset=0):
     reactions = []
 
     with local_session() as session:
-        for [reaction, user, shout, reacted_stat, commented_stat, rating_stat] in session.execute(q):
+        for [reaction, user, shout, reacted_stat, commented_stat, rating_stat] in session.execute(
+            q
+        ):
             reaction.createdBy = user
             reaction.shout = shout
             reaction.stat = {
                 "rating": rating_stat,
                 "commented": commented_stat,
-                "reacted": reacted_stat
+                "reacted": reacted_stat,
             }
 
             reaction.kind = reaction.kind.name

resolvers/zine/topics.py

@@ -1,24 +1,25 @@
-from sqlalchemy import and_, select, distinct, func
+from sqlalchemy import and_, distinct, func, select
 from sqlalchemy.orm import aliased
 
 from auth.authenticate import login_required
 from base.orm import local_session
 from base.resolvers import mutation, query
-from orm.shout import ShoutTopic, ShoutAuthor
-from orm.topic import Topic, TopicFollower
 from orm import User
+from orm.shout import ShoutAuthor, ShoutTopic
+from orm.topic import Topic, TopicFollower
 
 
 def add_topic_stat_columns(q):
     aliased_shout_author = aliased(ShoutAuthor)
     aliased_topic_follower = aliased(TopicFollower)
 
-    q = q.outerjoin(ShoutTopic, Topic.id == ShoutTopic.topic).add_columns(
-        func.count(distinct(ShoutTopic.shout)).label('shouts_stat')
-    ).outerjoin(aliased_shout_author, ShoutTopic.shout == aliased_shout_author.shout).add_columns(
-        func.count(distinct(aliased_shout_author.user)).label('authors_stat')
-    ).outerjoin(aliased_topic_follower).add_columns(
-        func.count(distinct(aliased_topic_follower.follower)).label('followers_stat')
+    q = (
+        q.outerjoin(ShoutTopic, Topic.id == ShoutTopic.topic)
+        .add_columns(func.count(distinct(ShoutTopic.shout)).label("shouts_stat"))
+        .outerjoin(aliased_shout_author, ShoutTopic.shout == aliased_shout_author.shout)
+        .add_columns(func.count(distinct(aliased_shout_author.user)).label("authors_stat"))
+        .outerjoin(aliased_topic_follower)
+        .add_columns(func.count(distinct(aliased_topic_follower.follower)).label("followers_stat"))
     )
 
     q = q.group_by(Topic.id)
@@ -28,11 +29,7 @@ def add_topic_stat_columns(q):
 
 def add_stat(topic, stat_columns):
     [shouts_stat, authors_stat, followers_stat] = stat_columns
-    topic.stat = {
-        "shouts": shouts_stat,
-        "authors": authors_stat,
-        "followers": followers_stat
-    }
+    topic.stat = {"shouts": shouts_stat, "authors": authors_stat, "followers": followers_stat}
 
     return topic
 
@@ -125,7 +122,8 @@ def topic_follow(user_id, slug):
             session.add(following)
             session.commit()
             return True
-    except:
+    except Exception as e:
+        print(e)
         return False
 
 
@@ -133,18 +131,17 @@ def topic_unfollow(user_id, slug):
     try:
         with local_session() as session:
             sub = (
-                session.query(TopicFollower).join(Topic).filter(
-                    and_(
-                        TopicFollower.follower == user_id,
-                        Topic.slug == slug
-                    )
-                ).first()
+                session.query(TopicFollower)
+                .join(Topic)
+                .filter(and_(TopicFollower.follower == user_id, Topic.slug == slug))
+                .first()
             )
             if sub:
                 session.delete(sub)
                 session.commit()
                 return True
-    except:
+    except Exception as e:
+        print(e)
         pass
     return False