Format and lint web directory (#67)

app/web/db/crud.py

@@ -1,15 +1,26 @@
 from collections import defaultdict
 from datetime import datetime, timedelta
-from functools import lru_cache
+from typing import Any, Type
 
 from cachetools import LRUCache, cached
 from cachetools.keys import hashkey
 from loguru import logger
-from sqlalchemy import Column, func, or_, select
+from sqlalchemy import (
+    Column,
+    ColumnElement,
+    ScalarResult,
+    false,
+    func,
+    not_,
+    or_,
+    select,
+    true,
+)
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session, load_only
 
 from app.shared.db import models
+from app.shared.db.models import Archive, Group
 from app.shared.settings import get_settings
 from app.shared.user_groups import UserGroups
 from app.shared.utils.misc import fnv1a_hash_mod
@@ -23,24 +34,48 @@ DATABASE_QUERY_LIMIT = get_settings().DATABASE_QUERY_LIMIT
 def get_limit(user_limit: int):
     return max(1, min(user_limit, DATABASE_QUERY_LIMIT))
 
+
 # --------------- TASK = Archive
 
 
 def base_query(db: Session):
-    # NOTE: load_only is for optimization and not obfuscation, use .with_entities() if needed
-    return db.query(models.Archive)\
-        .filter(models.Archive.deleted == False)\
-        .options(load_only(models.Archive.id, models.Archive.created_at, models.Archive.url, models.Archive.result, models.Archive.store_until))
+    # NOTE: load_only is for optimization and not obfuscation, use
+    # .with_entities() if needed
+    return (
+        db.query(models.Archive)
+        .filter(not_(models.Archive.deleted))
+        .options(
+            load_only(
+                models.Archive.id,
+                models.Archive.created_at,
+                models.Archive.url,
+                models.Archive.result,
+                models.Archive.store_until,
+            )
+        )
+    )
 
 
-def search_archives_by_url(db: Session, url: str, email: str, read_groups: bool | set[str], read_public: bool, skip: int = 0, limit: int = 100, archived_after: datetime = None, archived_before: datetime = None, absolute_search: bool = False) -> list[models.Archive]:
-    # searches for partial URLs, if email is * no ownership (or read/read_public) filtering happens
+def search_archives_by_url(
+    db: Session,
+    url: str,
+    email: str,
+    read_groups: bool | set[str],
+    read_public: bool,
+    skip: int = 0,
+    limit: int = 100,
+    archived_after: datetime = None,
+    archived_before: datetime = None,
+    absolute_search: bool = False,
+) -> list[Type[Archive]]:
+    # searches for partial URLs, if email is * no ownership
+    # (or read/read_public) filtering happens
     query = base_query(db)
     if email != ALLOW_ANY_EMAIL:
         or_filters = [models.Archive.author_id == email]
         if read_public:
-            or_filters.append(models.Archive.public == True)
-        if read_groups == True:
+            or_filters.append(models.Archive.public.is_(true()))
+        if read_groups is True:
             or_filters.append(models.Archive.group_id.isnot(None))
         else:
             or_filters.append(models.Archive.group_id.in_(read_groups))
@@ -48,21 +83,43 @@ def search_archives_by_url(db: Session, url: str, email: str, read_groups: bool
     if absolute_search:
         query = query.filter(models.Archive.url == url)
     else:
-        query = query.filter(models.Archive.url.like(f'%{url}%'))
+        query = query.filter(models.Archive.url.like(f"%{url}%"))
     if archived_after:
         query = query.filter(models.Archive.created_at > archived_after)
     if archived_before:
         query = query.filter(models.Archive.created_at < archived_before)
-    return query.order_by(models.Archive.created_at.desc()).offset(skip).limit(get_limit(limit)).all()
+    return (
+        query.order_by(models.Archive.created_at.desc())
+        .offset(skip)
+        .limit(get_limit(limit))
+        .all()
+    )
 
 
-def search_archives_by_email(db: Session, email: str, skip: int = 0, limit: int = 100):
-    return base_query(db).filter(models.Archive.author_id == email).order_by(models.Archive.created_at.desc()).offset(skip).limit(get_limit(limit)).all()
+def search_archives_by_email(
+    db: Session, email: str, skip: int = 0, limit: int = 100
+):
+    return (
+        base_query(db)
+        .filter(models.Archive.author_id == email)
+        .order_by(models.Archive.created_at.desc())
+        .offset(skip)
+        .limit(get_limit(limit))
+        .all()
+    )
 
 
 def soft_delete_archive(db: Session, id: str, email: str) -> bool:
     # TODO: implement hard-delete with cronjob that deletes from S3
-    db_archive = db.query(models.Archive).filter(models.Archive.id == id, models.Archive.author_id == email, models.Archive.deleted == False).first()
+    db_archive = (
+        db.query(models.Archive)
+        .filter(
+            models.Archive.id == id,
+            models.Archive.author_id == email,
+            models.Archive.deleted.is_(false()),
+        )
+        .first()
+    )
     if db_archive:
         db_archive.deleted = True
         db.commit()
@@ -83,22 +140,29 @@ def count_users(db: Session):
 
 def count_by_user_since(db: Session, seconds_delta: int = 15):
     time_threshold = datetime.now() - timedelta(seconds=seconds_delta)
-    return db.query(models.Archive.author_id, func.count().label('total'))\
-        .filter(models.Archive.created_at >= time_threshold)\
-        .group_by(models.Archive.author_id)\
-        .order_by(func.count().desc())\
-        .limit(500).all()
+    return (
+        db.query(models.Archive.author_id, func.count().label("total"))
+        .filter(models.Archive.created_at >= time_threshold)
+        .group_by(models.Archive.author_id)
+        .order_by(func.count().desc())
+        .limit(500)
+        .all()
+    )
 
 
-async def find_by_store_until(db: AsyncSession, store_until_is_before: datetime) -> list[models.Archive]:
+async def find_by_store_until(
+    db: AsyncSession, store_until_is_before: datetime
+) -> ScalarResult[Archive]:
     res = await db.execute(
-        select(models.Archive)
-        .filter(models.Archive.deleted == False, models.Archive.store_until < store_until_is_before)
+        select(models.Archive).filter(
+            models.Archive.deleted.is_(false()),
+            models.Archive.store_until < store_until_is_before,
+        )
     )
     return res.scalars()
 
 
-async def soft_delete_expired_archives(db: AsyncSession) -> dict:
+async def soft_delete_expired_archives(db: AsyncSession) -> int:
     to_delete = await find_by_store_until(db, datetime.now())
     counter = 0
     for archive in to_delete:
@@ -106,47 +170,86 @@ async def soft_delete_expired_archives(db: AsyncSession) -> dict:
         counter += 1
     await db.commit()
     return counter
+
+
 # --------------- TAG
 
 
 async def get_group_priority_async(db: AsyncSession, group_id: str) -> dict:
     db_group = await db.get(models.Group, group_id)
-    priority = db_group.permissions.get("priority", "low") if db_group else "low"
+    priority = (
+        db_group.permissions.get("priority", "low") if db_group else "low"
+    )
     return convert_priority_to_queue_dict(priority)
 
 
 @cached(cache=LRUCache(maxsize=128), key=lambda db, email: hashkey(email))
-def get_user_group_names(db: Session, email: str) -> list[str]:
+def get_user_group_names(
+    db: Session, email: str
+) -> list[Any] | list[ColumnElement[Any]]:
     """
-    given an email retrieves the user groups from the DB and then the email-domain groups from a global variable, the email does not need to belong to an existing user.
+    given an email retrieves the user groups from the DB and then the
+    email-domain groups from a global variable, the email does not need to
+    belong to an existing user.
     """
     # TODO: the read: [group1, group2] permissions don't currently work
-    if not email or not len(email) or "@" not in email: return []
+    if not email or not len(email) or "@" not in email:
+        return []
 
     # get user groups
-    user_groups = db.query(models.association_table_user_groups).filter_by(user_id=email).with_entities(Column("group_id")).all()
+    user_groups = (
+        db.query(models.association_table_user_groups)
+        .filter_by(user_id=email)
+        .with_entities(Column("group_id"))
+        .all()
+    )
     user_level_groups_names = [g[0] for g in user_groups]
 
     # get domain groups
-    domain = email.split('@')[1]
-    domain_level_groups = db.query(models.Group.id).filter(models.Group.domains.contains(domain)).with_entities(Column("id")).all()
+    domain = email.split("@")[1]
+    domain_level_groups = (
+        db.query(models.Group.id)
+        .filter(models.Group.domains.contains(domain))
+        .with_entities(Column("id"))
+        .all()
+    )
     domain_level_groups_names = [g[0] for g in domain_level_groups]
 
     return list(set(user_level_groups_names + domain_level_groups_names))
 
 
-def get_user_groups_by_name(db: Session, groups: list[str]) -> list[models.Group]:
-    return db.query(models.Group).filter(
-        models.Group.id.in_(groups)
-    ).all()
+def get_user_groups_by_name(
+    db: Session, groups: list[str]
+) -> list[Type[Group]]:
+    return db.query(models.Group).filter(models.Group.id.in_(groups)).all()
+
 
 # --------------- INIT User-Groups
 
 
-def upsert_group(db: Session, group_name: str, description: str, orchestrator: str, orchestrator_sheet: str, service_account_email: str, permissions: dict, domains: list) -> models.Group:
-    db_group = db.query(models.Group).filter(models.Group.id == group_name).first()
+def upsert_group(
+    db: Session,
+    group_name: str,
+    description: str,
+    orchestrator: str,
+    orchestrator_sheet: str,
+    service_account_email: str,
+    permissions: dict,
+    domains: list,
+) -> models.Group:
+    db_group = (
+        db.query(models.Group).filter(models.Group.id == group_name).first()
+    )
     if db_group is None:
-        db_group = models.Group(id=group_name, description=description, orchestrator=orchestrator, orchestrator_sheet=orchestrator_sheet, service_account_email=service_account_email, permissions=permissions, domains=domains)
+        db_group = models.Group(
+            id=group_name,
+            description=description,
+            orchestrator=orchestrator,
+            orchestrator_sheet=orchestrator_sheet,
+            service_account_email=service_account_email,
+            permissions=permissions,
+            domains=domains,
+        )
         db.add(db_group)
     else:
         db_group.description = description
@@ -173,6 +276,7 @@ def upsert_user(db: Session, email: str):
 def upsert_user_groups(db: Session):
     def display_email_pii(email: str):
         return f"'{email[0:3]}...@{email.split('@')[1]}'"
+
     """
     reads the user_groups yaml file and inserts any new users, groups,
     along with new participation of users in groups
@@ -196,16 +300,30 @@ def upsert_user_groups(db: Session):
 
     # upsert groups and save a map of groupid -> dbobject
     for group_id, g in ug.groups.items():
-        upsert_group(db, group_id, g.description, g.orchestrator, g.orchestrator_sheet, g.service_account_email, json.loads(g.permissions.model_dump_json()), list(group_domains.get(group_id, [])))
-    db_groups: dict[str, models.Group] = {g.id: g for g in db.query(models.Group).all()}
+        upsert_group(
+            db,
+            group_id,
+            g.description,
+            g.orchestrator,
+            g.orchestrator_sheet,
+            g.service_account_email,
+            json.loads(g.permissions.model_dump_json()),
+            list(group_domains.get(group_id, [])),
+        )
+    db_groups: dict[str, models.Group] = {
+        g.id: g for g in db.query(models.Group).all()
+    }
 
     # integrity checks
     for group_in_domains in group_domains:
         if group_in_domains not in db_groups:
-            logger.warning(f"[CONFIG] Group '{group_in_domains}' does not exist in the database: domains setting will not work.")
+            logger.warning(
+                f"[CONFIG] Group '{group_in_domains}' does not exist in the database: domains setting will not work."
+            )
 
     # reinsert users in their EXPLICITLY DEFINED groups
-    # domain groups are check live, as there may be new users that are not explicitly registered but belong to a domain
+    # domain groups are check live, as there may be new users that are not
+    # explicitly registered but belong to a domain
     for email, explicit_groups in ug.users.items():
         explicit_groups = explicit_groups or []
         logger.info(f"EXPLICIT {display_email_pii(email)} => {explicit_groups}")
@@ -215,7 +333,9 @@ def upsert_user_groups(db: Session):
         # connect users to groups
         for group_id in explicit_groups:
             if group_id not in db_groups:
-                logger.warning(f"[CONFIG] Group {group_id} does not exist in config file, skipping for email={display_email_pii(email)}.")
+                logger.warning(
+                    f"[CONFIG] Group {group_id} does not exist in config file, skipping for email={display_email_pii(email)}."
+                )
                 continue
             db_groups[group_id].users.append(db_user)
 
@@ -223,12 +343,27 @@ def upsert_user_groups(db: Session):
     count_user_groups = db.query(models.association_table_user_groups).count()
     count_groups = db.query(func.count(models.Group.id)).scalar()
 
-    logger.success(f"[CONFIG] DONE: [users={count_users(db)}, groups={count_groups}, explicit user groups={count_user_groups}].")
+    logger.success(
+        f"[CONFIG] DONE: [users={count_users(db)}, groups={count_groups}, explicit user groups={count_user_groups}]."
+    )
 
 
 # --------------- SHEET
-def create_sheet(db: Session, sheet_id: str, name: str, email: str, group_id: str, frequency: str):
-    db_sheet = models.Sheet(id=sheet_id, name=name, author_id=email, group_id=group_id, frequency=frequency)
+def create_sheet(
+    db: Session,
+    sheet_id: str,
+    name: str,
+    email: str,
+    group_id: str,
+    frequency: str,
+):
+    db_sheet = models.Sheet(
+        id=sheet_id,
+        name=name,
+        author_id=email,
+        group_id=group_id,
+        frequency=frequency,
+    )
     db.add(db_sheet)
     db.commit()
     db.refresh(db_sheet)
@@ -236,20 +371,31 @@ def create_sheet(db: Session, sheet_id: str, name: str, email: str, group_id: st
 
 
 def get_user_sheet(db: Session, email: str, sheet_id: str) -> models.Sheet:
-    return db.query(models.Sheet).filter(models.Sheet.author_id == email, models.Sheet.id == sheet_id).first()
+    return (
+        db.query(models.Sheet)
+        .filter(models.Sheet.author_id == email, models.Sheet.id == sheet_id)
+        .first()
+    )
 
 
 def get_user_sheets(db: Session, email: str) -> list[models.Sheet]:
-    return db.query(models.Sheet).filter(models.Sheet.author_id == email).order_by(models.Sheet.last_url_archived_at.desc()).all()
+    return (
+        db.query(models.Sheet)
+        .filter(models.Sheet.author_id == email)
+        .order_by(models.Sheet.last_url_archived_at.desc())
+        .all()
+    )
 
 
-async def get_sheets_by_id_hash(db: AsyncSession, frequency: str, modulo: str, id_hash: int) -> list[models.Sheet]:
+async def get_sheets_by_id_hash(
+    db: AsyncSession, frequency: str, modulo: str, id_hash: int
+) -> list[models.Sheet]:
     result = await db.execute(
         select(models.Sheet).filter(models.Sheet.frequency == frequency)
     )
     filtered = []
     for sheet in result.scalars():
-        if fnv1a_hash_mod(sheet.id, modulo) == id_hash:
+        if fnv1a_hash_mod(sheet.id, int(modulo)) == id_hash:
             filtered.append(sheet)
     return filtered
 
@@ -257,7 +403,9 @@ async def get_sheets_by_id_hash(db: AsyncSession, frequency: str, modulo: str, i
 async def delete_stale_sheets(db: AsyncSession, inactivity_days: int) -> dict:
     time_threshold = datetime.now() - timedelta(days=inactivity_days)
     result = await db.execute(
-        select(models.Sheet).filter(models.Sheet.last_url_archived_at < time_threshold)
+        select(models.Sheet).filter(
+            models.Sheet.last_url_archived_at < time_threshold
+        )
     )
     deleted = defaultdict(list)
     for sheet in result.scalars():
@@ -268,7 +416,11 @@ async def delete_stale_sheets(db: AsyncSession, inactivity_days: int) -> dict:
 
 
 def delete_sheet(db: Session, sheet_id: str, email: str) -> bool:
-    db_sheet = db.query(models.Sheet).filter(models.Sheet.id == sheet_id, models.Sheet.author_id == email).first()
+    db_sheet = (
+        db.query(models.Sheet)
+        .filter(models.Sheet.id == sheet_id, models.Sheet.author_id == email)
+        .first()
+    )
     if db_sheet:
         db.delete(db_sheet)
         db.commit()

app/web/db/user_state.py

@@ -1,4 +1,3 @@
-
 from datetime import datetime
 from typing import Dict, Set
 
@@ -21,14 +20,15 @@ class UserState:
     def __init__(self, db: Session, email: str):
         self.db = db
         self.email = email.lower()
+        self._permissions = {}
 
     @property
     def permissions(self) -> Dict[str, GroupInfo]:
         """
-        Returns a dict of all group permissions and a special {"all": read/archive_url/archive_sheet} key
+        Returns a dict of all group permissions and a special
+        {"all": read/archive_url/archive_sheet} key
         """
-        if not hasattr(self, '_permissions'):
-            self._permissions = {}
+        if not self._permissions:
             self._permissions["all"] = GroupInfo(
                 read=self.read,
                 read_public=self.read_public,
@@ -38,23 +38,33 @@ class UserState:
                 max_archive_lifespan_months=self.max_archive_lifespan_months,
                 max_monthly_urls=self.max_monthly_urls,
                 max_monthly_mbs=self.max_monthly_mbs,
-                priority=self.priority
+                priority=self.priority,
             )
             for group in self.user_groups:
-                if not group.permissions: continue
-                self._permissions[group.id] = GroupInfo(**group.permissions, description=group.description, service_account_email=group.service_account_email)
+                if not group.permissions:
+                    continue
+                self._permissions[group.id] = GroupInfo(
+                    **group.permissions,
+                    description=group.description,
+                    service_account_email=group.service_account_email,
+                )
         return self._permissions
 
     @property
     def user_groups_names(self):
-        if not hasattr(self, '_user_groups_names'):
-            self._user_groups_names = crud.get_user_group_names(self.db, self.email) + ["default"]
+        if not hasattr(self, "_user_groups_names"):
+            # TODO: Define hidden properties in __init__ method
+            self._user_groups_names = crud.get_user_group_names(
+                self.db, self.email
+            ) + ["default"]
         return self._user_groups_names
 
     @property
     def user_groups(self):
-        if not hasattr(self, '_user_groups'):
-            self._user_groups = crud.get_user_groups_by_name(self.db, self.user_groups_names)
+        if not hasattr(self, "_user_groups"):
+            self._user_groups = crud.get_user_groups_by_name(
+                self.db, self.user_groups_names
+            )
         return self._user_groups
 
     @property
@@ -62,10 +72,11 @@ class UserState:
         """
         Read can be a list of group names or True, if all can be read.
         """
-        if not hasattr(self, '_read'):
+        if not hasattr(self, "_read"):
             self._read = set()
             for group in self.user_groups:
-                if not group.permissions: continue
+                if not group.permissions:
+                    continue
                 group_read_permissions = group.permissions.get("read", [])
                 if "all" in group_read_permissions:
                     self._read = True
@@ -79,10 +90,11 @@ class UserState:
         """
         Read public permission
         """
-        if not hasattr(self, '_read_public'):
+        if not hasattr(self, "_read_public"):
             self._read_public = False
             for group in self.user_groups:
-                if not group.permissions: continue
+                if not group.permissions:
+                    continue
                 if group.permissions.get("read_public", False):
                     self._read_public = True
                     return self._read_public
@@ -93,10 +105,11 @@ class UserState:
         """
         Archive URL permission
         """
-        if not hasattr(self, '_archive_url'):
+        if not hasattr(self, "_archive_url"):
             self._archive_url = False
             for group in self.user_groups:
-                if not group.permissions: continue
+                if not group.permissions:
+                    continue
                 if group.permissions.get("archive_url", False):
                     self._archive_url = True
                     return self._archive_url
@@ -107,10 +120,11 @@ class UserState:
         """
         Archive sheet permission
         """
-        if not hasattr(self, '_archive_sheet'):
+        if not hasattr(self, "_archive_sheet"):
             self._archive_sheet = False
             for group in self.user_groups:
-                if not group.permissions: continue
+                if not group.permissions:
+                    continue
                 if group.permissions.get("archive_sheet", False):
                     self._archive_sheet = True
                     return self._archive_sheet
@@ -118,37 +132,53 @@ class UserState:
 
     @property
     def sheet_frequency(self):
-        if not hasattr(self, '_sheet_frequency'):
+        if not hasattr(self, "_sheet_frequency"):
             self._sheet_frequency = set()
             for group in self.user_groups:
-                if not group.permissions: continue
-                self._sheet_frequency.update(group.permissions.get("sheet_frequency", None))
+                if not group.permissions:
+                    continue
+                self._sheet_frequency.update(
+                    group.permissions.get("sheet_frequency", None)
+                )
         return self._sheet_frequency
 
     @property
     def max_archive_lifespan_months(self) -> int:
-        if not hasattr(self, '_max_archive_lifespan_months'):
-            self._max_archive_lifespan_months = self._helper_for_grouping_max_numerical_permissions("max_archive_lifespan_months")
+        if not hasattr(self, "_max_archive_lifespan_months"):
+            self._max_archive_lifespan_months = (
+                self._helper_for_grouping_max_numerical_permissions(
+                    "max_archive_lifespan_months"
+                )
+            )
         return self._max_archive_lifespan_months
 
     @property
     def max_monthly_urls(self) -> int:
-        if not hasattr(self, '_max_monthly_urls'):
-            self._max_monthly_urls = self._helper_for_grouping_max_numerical_permissions("max_monthly_urls")
+        if not hasattr(self, "_max_monthly_urls"):
+            self._max_monthly_urls = (
+                self._helper_for_grouping_max_numerical_permissions(
+                    "max_monthly_urls"
+                )
+            )
         return self._max_monthly_urls
 
     @property
     def max_monthly_mbs(self) -> int:
-        if not hasattr(self, '_max_monthly_mbs'):
-            self._max_monthly_mbs = self._helper_for_grouping_max_numerical_permissions("max_monthly_mbs")
+        if not hasattr(self, "_max_monthly_mbs"):
+            self._max_monthly_mbs = (
+                self._helper_for_grouping_max_numerical_permissions(
+                    "max_monthly_mbs"
+                )
+            )
         return self._max_monthly_mbs
 
     @property
     def priority(self) -> str:
-        if not hasattr(self, '_priority'):
+        if not hasattr(self, "_priority"):
             self._priority = "low"
             for group in self.user_groups:
-                if not group.permissions: continue
+                if not group.permissions:
+                    continue
                 if group.permissions.get("priority", self._priority) == "high":
                     self._priority = "high"
                     break
@@ -159,18 +189,28 @@ class UserState:
         """
         A user is active if they can read/archive anything
         """
-        if not hasattr(self, '_active'):
-            self._active = bool(self.read or self.read_public or self.archive_url or self.archive_sheet)
+        if not hasattr(self, "_active"):
+            self._active = bool(
+                self.read
+                or self.read_public
+                or self.archive_url
+                or self.archive_sheet
+            )
         return self._active
 
-    def _helper_for_grouping_max_numerical_permissions(self, permission_name: str) -> int:
+    def _helper_for_grouping_max_numerical_permissions(
+        self, permission_name: str
+    ) -> int:
         """
-        Iterates one of the numerical permissions where -1 means no restrictions and returns either -1 or the maximum value, defaults according to GroupPermissions
+        Iterates one of the numerical permissions where -1 means no restrictions
+        and returns either -1 or the maximum value, defaults according to
+        GroupPermissions
         """
         default = GroupPermissions.model_fields[permission_name].default
         max_value = default
         for group in self.user_groups:
-            if not group.permissions: continue
+            if not group.permissions:
+                continue
             group_value = group.permissions.get(permission_name, default)
             if group_value == -1:
                 max_value = -1
@@ -181,43 +221,65 @@ class UserState:
     def in_group(self, group_id: str) -> bool:
         return group_id in self.user_groups_names
 
-    def usage(self) -> Dict:
+    def usage(self) -> UsageResponse:
         """
-        returns the monthly quotas for the URLs/MBs and the totals for Sheets
+        Returns the monthly quotas for the URLs/MBs and the totals for Sheets
         """
         current_month = datetime.now().month
         current_year = datetime.now().year
 
         # find and sum all user sheets over this month
-        user_sheets = self.db.query(
-            models.Sheet.group_id,
-            func.count(models.Sheet.id).label('sheet_count')
-        ).filter(models.Sheet.author_id == self.email).group_by(models.Sheet.group_id).all()
+        user_sheets = (
+            self.db.query(
+                models.Sheet.group_id,
+                func.count(models.Sheet.id).label("sheet_count"),
+            )
+            .filter(models.Sheet.author_id == self.email)
+            .group_by(models.Sheet.group_id)
+            .all()
+        )
 
-        sheets_by_group = {sheet.group_id: sheet.sheet_count for sheet in user_sheets}
+        sheets_by_group = {
+            sheet.group_id: sheet.sheet_count for sheet in user_sheets
+        }
 
         # find and sum all user urls over this month
-        urls_by_group = self.db.query(
-            models.Archive.group_id,
-            func.count(models.Archive.id).label('url_count'),
-            func.coalesce(func.sum(
+        urls_by_group = (
+            self.db.query(
+                models.Archive.group_id,
+                func.count(models.Archive.id).label("url_count"),
                 func.coalesce(
-                    func.cast(
-                        func.json_extract(models.Archive.result, '$.metadata.total_bytes'),
-                        sqlalchemy.Integer
-                    ), 0
-                )
-            ), 0).label('total_bytes')
-        ).filter(
-            models.Archive.author_id == self.email,
-            func.extract('month', models.Archive.created_at) == current_month,
-            func.extract('year', models.Archive.created_at) == current_year
-        ).group_by(models.Archive.group_id).all()
+                    func.sum(
+                        func.coalesce(
+                            func.cast(
+                                func.json_extract(
+                                    models.Archive.result,
+                                    "$.metadata.total_bytes",
+                                ),
+                                sqlalchemy.Integer,
+                            ),
+                            0,
+                        )
+                    ),
+                    0,
+                ).label("total_bytes"),
+            )
+            .filter(
+                models.Archive.author_id == self.email,
+                func.extract("month", models.Archive.created_at)
+                == current_month,
+                func.extract("year", models.Archive.created_at) == current_year,
+            )
+            .group_by(models.Archive.group_id)
+            .all()
+        )
 
         # merge the two queries
         usage_by_group: Dict[str, Usage] = {
-            (url.group_id or ""):
-            Usage(monthly_urls=url.url_count, monthly_mbs=int(url.total_bytes / 1024 / 1024))
+            (url.group_id or ""): Usage(
+                monthly_urls=url.url_count,
+                monthly_mbs=int(url.total_bytes / 1024 / 1024),
+            )
             for url in urls_by_group
         }
         for group_id, sheet_count in sheets_by_group.items():
@@ -236,7 +298,7 @@ class UserState:
             monthly_urls=total_urls,
             monthly_mbs=int(total_bytes / 1024 / 1024),
             total_sheets=total_sheets,
-            groups=usage_by_group
+            groups=usage_by_group,
         )
 
     def has_quota_monthly_sheets(self, group_id: str) -> bool:
@@ -246,7 +308,14 @@ class UserState:
         if group_id not in self.permissions:
             return False
 
-        user_sheets = self.db.query(models.Sheet).filter(models.Sheet.author_id == self.email, models.Sheet.group_id == group_id).count()
+        user_sheets = (
+            self.db.query(models.Sheet)
+            .filter(
+                models.Sheet.author_id == self.email,
+                models.Sheet.group_id == group_id,
+            )
+            .count()
+        )
 
         sheet_quota = self.permissions[group_id].max_sheets
         if sheet_quota == -1:
@@ -255,13 +324,15 @@ class UserState:
 
     def has_quota_max_monthly_urls(self, group_id: str) -> bool:
         """
-        checks if a user has reached their monthly url quota for a group, if global then group should be empty string
+        Checks if a user has reached their monthly url quota for a group, if
+        global then group should be empty string
         """
         quota = 0
         if not group_id:
             quota = self.max_monthly_urls
         else:
-            if group_id not in self.permissions: return False
+            if group_id not in self.permissions:
+                return False
             quota = self.permissions[group_id].max_monthly_urls
 
         if quota == -1:
@@ -269,24 +340,31 @@ class UserState:
 
         current_month = datetime.now().month
         current_year = datetime.now().year
-        user_urls = self.db.query(models.Archive).filter(
-            models.Archive.author_id == self.email,
-            models.Archive.group_id == group_id,
-            func.extract('month', models.Archive.created_at) == current_month,
-            func.extract('year', models.Archive.created_at) == current_year
-        ).count()
+        user_urls = (
+            self.db.query(models.Archive)
+            .filter(
+                models.Archive.author_id == self.email,
+                models.Archive.group_id == group_id,
+                func.extract("month", models.Archive.created_at)
+                == current_month,
+                func.extract("year", models.Archive.created_at) == current_year,
+            )
+            .count()
+        )
 
         return user_urls < quota
 
     def has_quota_max_monthly_mbs(self, group_id: str) -> bool:
         """
-        checks if a user has reached their monthly MBs quota for a group, if global then group should be empty string
+        Checks if a user has reached their monthly MBs quota for a group, if
+        global then group should be empty string
         """
         quota = 0
         if not group_id:
             quota = self.max_monthly_mbs
         else:
-            if group_id not in self.permissions: return False
+            if group_id not in self.permissions:
+                return False
             quota = self.permissions[group_id].max_monthly_mbs
 
         if quota == -1:
@@ -296,19 +374,34 @@ class UserState:
         current_year = datetime.now().year
 
         # find and sum all user bytes over this month
-        user_bytes = self.db.query(models.Archive).filter(
-            models.Archive.author_id == self.email,
-            models.Archive.group_id == group_id,
-            func.extract('month', models.Archive.created_at) == current_month,
-            func.extract('year', models.Archive.created_at) == current_year
-        ).with_entities(func.coalesce(func.sum(
-            func.coalesce(
-                func.cast(
-                    func.json_extract(models.Archive.result, '$.metadata.total_bytes'),
-                    sqlalchemy.Integer
-                ), 0
+        user_bytes = (
+            self.db.query(models.Archive)
+            .filter(
+                models.Archive.author_id == self.email,
+                models.Archive.group_id == group_id,
+                func.extract("month", models.Archive.created_at)
+                == current_month,
+                func.extract("year", models.Archive.created_at) == current_year,
             )
-        ), 0).label('total')).scalar()
+            .with_entities(
+                func.coalesce(
+                    func.sum(
+                        func.coalesce(
+                            func.cast(
+                                func.json_extract(
+                                    models.Archive.result,
+                                    "$.metadata.total_bytes",
+                                ),
+                                sqlalchemy.Integer,
+                            ),
+                            0,
+                        )
+                    ),
+                    0,
+                ).label("total")
+            )
+            .scalar()
+        )
 
         # convert bytes to mb
         user_mbs = int(user_bytes / 1024 / 1024)
@@ -316,7 +409,7 @@ class UserState:
 
     def can_manually_trigger(self, group_id: str) -> bool:
         """
-        checks if a user is allowed to manually trigger a sheet
+        Checks if a user is allowed to manually trigger a sheet
         """
         if group_id not in self.permissions:
             return False
@@ -325,18 +418,21 @@ class UserState:
 
     def is_sheet_frequency_allowed(self, group_id: str, frequency: str) -> bool:
         """
-        checks if a user is allowed to create a sheet with this frequency for this group
+        Checks if a user is allowed to create a sheet with this frequency for
+        this group
         """
         if group_id not in self.permissions:
             return False
 
         return frequency in self.permissions[group_id].sheet_frequency
 
-    def priority_group(self, group_id: str) -> str:
+    def priority_group(self, group_id: str) -> dict:
         priority = "low"
         for group in self.user_groups:
-            if group.id != group_id: continue
-            if not group.permissions: continue
+            if group.id != group_id:
+                continue
+            if not group.permissions:
+                continue
             priority = group.permissions.get("priority", priority)
             break
         return convert_priority_to_queue_dict(priority)