chore: format

Author: tjbck

backend/open_webui/env.py

@@ -431,9 +431,7 @@ def parse_section(section):
 # enabled, the kernel sends TCP keepalive probes on idle connections so
 # half-closed sockets (e.g. after a silent firewall/LB reset or a NIC
 # flap) are detected before the next command lands on them.
-REDIS_SOCKET_KEEPALIVE = (
-    os.environ.get('REDIS_SOCKET_KEEPALIVE', 'False').lower() == 'true'
-)
+REDIS_SOCKET_KEEPALIVE = os.environ.get('REDIS_SOCKET_KEEPALIVE', 'False').lower() == 'true'
 
 # How often (in seconds) redis-py should PING an idle pooled connection
 # before reusing it. Opt-in: defaults to unset (empty string) so behavior

backend/open_webui/internal/db.py

@@ -214,6 +214,7 @@ def get_session():
     )
 
     if DATABASE_ENABLE_SQLITE_WAL:
+
         @event.listens_for(async_engine.sync_engine, 'connect')
         def _set_sqlite_wal(dbapi_connection, connection_record):
             cursor = dbapi_connection.cursor()

backend/open_webui/main.py

@@ -723,6 +723,7 @@ async def lifespan(app: FastAPI):
 
     # Shutdown: clean up shared resources
     from open_webui.utils.session_pool import close_session
+
     await close_session()
 
     if hasattr(app.state, 'redis_task_command_listener'):
@@ -1397,7 +1398,6 @@ async def dispatch(self, request: Request, call_next):
 app.add_middleware(SecurityHeadersMiddleware)
 
 
-
 @app.middleware('http')
 async def commit_session_after_request(request: Request, call_next):
     response = await call_next(request)
@@ -1992,7 +1992,7 @@ async def list_tasks_endpoint(request: Request, user=Depends(get_admin_user)):
 @app.get('/api/tasks/chat/{chat_id:path}')
 async def list_tasks_by_chat_id_endpoint(request: Request, chat_id: str, user=Depends(get_verified_user)):
     if chat_id.startswith('local:'):
-        socket_id = chat_id[len('local:'):]
+        socket_id = chat_id[len('local:') :]
         owner_id = get_user_id_from_session_pool(socket_id)
         if owner_id != user.id and user.role != 'admin':
             return {'task_ids': []}
@@ -2010,7 +2010,7 @@ async def list_tasks_by_chat_id_endpoint(request: Request, chat_id: str, user=De
 @app.post('/api/tasks/chat/{chat_id:path}/stop')
 async def stop_tasks_by_chat_id_endpoint(request: Request, chat_id: str, user=Depends(get_verified_user)):
     if chat_id.startswith('local:'):
-        socket_id = chat_id[len('local:'):]
+        socket_id = chat_id[len('local:') :]
         owner_id = get_user_id_from_session_pool(socket_id)
         if owner_id != user.id and user.role != 'admin':
             raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=ERROR_MESSAGES.NOT_FOUND)

backend/open_webui/models/access_grants.py

@@ -295,8 +295,7 @@ async def grant_access(
         async with get_async_db_context(db) as db:
             # Check for existing grant
             result = await db.execute(
-                select(AccessGrant)
-                .filter_by(
+                select(AccessGrant).filter_by(
                     resource_type=resource_type,
                     resource_id=resource_id,
                     principal_type=principal_type,
@@ -334,8 +333,7 @@ async def revoke_access(
         """Remove a single access grant."""
         async with get_async_db_context(db) as db:
             result = await db.execute(
-                delete(AccessGrant)
-                .filter_by(
+                delete(AccessGrant).filter_by(
                     resource_type=resource_type,
                     resource_id=resource_id,
                     principal_type=principal_type,
@@ -355,8 +353,7 @@ async def revoke_all_access(
         """Remove all access grants for a resource."""
         async with get_async_db_context(db) as db:
             result = await db.execute(
-                delete(AccessGrant)
-                .filter_by(
+                delete(AccessGrant).filter_by(
                     resource_type=resource_type,
                     resource_id=resource_id,
                 )
@@ -451,8 +448,7 @@ async def get_access_control(
         """
         async with get_async_db_context(db) as db:
             result = await db.execute(
-                select(AccessGrant)
-                .filter_by(
+                select(AccessGrant).filter_by(
                     resource_type=resource_type,
                     resource_id=resource_id,
                 )
@@ -470,8 +466,7 @@ async def get_grants_by_resource(
         """Get all grants for a specific resource."""
         async with get_async_db_context(db) as db:
             result = await db.execute(
-                select(AccessGrant)
-                .filter_by(
+                select(AccessGrant).filter_by(
                     resource_type=resource_type,
                     resource_id=resource_id,
                 )
@@ -490,8 +485,7 @@ async def get_grants_by_resources(
             return {}
         async with get_async_db_context(db) as db:
             result = await db.execute(
-                select(AccessGrant)
-                .filter(
+                select(AccessGrant).filter(
                     AccessGrant.resource_type == resource_type,
                     AccessGrant.resource_id.in_(resource_ids),
                 )
@@ -634,8 +628,7 @@ async def get_users_with_access(
 
         async with get_async_db_context(db) as db:
             result = await db.execute(
-                select(AccessGrant)
-                .filter_by(
+                select(AccessGrant).filter_by(
                     resource_type=resource_type,
                     resource_id=resource_id,
                     permission=permission,

backend/open_webui/models/auths.py

@@ -141,7 +141,9 @@ async def authenticate_user(
         except Exception:
             return None
 
-    async def authenticate_user_by_api_key(self, api_key: str, db: Optional[AsyncSession] = None) -> Optional[UserModel]:
+    async def authenticate_user_by_api_key(
+        self, api_key: str, db: Optional[AsyncSession] = None
+    ) -> Optional[UserModel]:
         log.info(f'authenticate_user_by_api_key')
         # if no api_key, return None
         if not api_key:
@@ -159,9 +161,7 @@ async def authenticate_user_by_email(self, email: str, db: Optional[AsyncSession
             async with get_async_db_context(db) as db:
                 # Single JOIN query instead of two separate queries
                 result = await db.execute(
-                    select(Auth, User)
-                    .join(User, Auth.id == User.id)
-                    .filter(Auth.email == email, Auth.active == True)
+                    select(Auth, User).join(User, Auth.id == User.id).filter(Auth.email == email, Auth.active == True)
                 )
                 row = result.first()
                 if row:

backend/open_webui/models/automations.py

@@ -145,9 +145,7 @@ async def insert(
 
     async def count_by_user(self, user_id: str, db: Optional[AsyncSession] = None) -> int:
         async with get_async_db_context(db) as db:
-            result = await db.execute(
-                select(func.count()).select_from(Automation).filter_by(user_id=user_id)
-            )
+            result = await db.execute(select(func.count()).select_from(Automation).filter_by(user_id=user_id))
             return result.scalar()
 
     async def get_by_id(self, id: str, db: Optional[AsyncSession] = None) -> Optional[AutomationModel]:
@@ -185,9 +183,7 @@ async def search_automations(
             stmt = stmt.order_by(Automation.created_at.desc())
 
             # Get total count
-            count_result = await db.execute(
-                select(func.count()).select_from(stmt.subquery())
-            )
+            count_result = await db.execute(select(func.count()).select_from(stmt.subquery()))
             total = count_result.scalar()
 
             if skip:
@@ -343,18 +339,14 @@ async def get_latest_batch(
                 .subquery()
             )
             result = await db.execute(
-                select(AutomationRun)
-                .join(
+                select(AutomationRun).join(
                     subq,
                     (AutomationRun.automation_id == subq.c.automation_id)
                     & (AutomationRun.created_at == subq.c.max_created),
                 )
             )
             rows = result.scalars().all()
-            return {
-                row.automation_id: AutomationRunModel.model_validate(row)
-                for row in rows
-            }
+            return {row.automation_id: AutomationRunModel.model_validate(row) for row in rows}
 
     async def get_by_automation(
         self,

backend/open_webui/models/channels.py

@@ -414,9 +414,13 @@ async def get_channels_by_user_id(self, user_id: str, db: Optional[AsyncSession]
             all_channels = list(membership_channels) + list(standard_channels)
             channel_ids = [c.id for c in all_channels]
             grants_map = await AccessGrants.get_grants_by_resources('channel', channel_ids, db=db)
-            return [await self._to_channel_model(c, access_grants=grants_map.get(c.id, []), db=db) for c in all_channels]
+            return [
+                await self._to_channel_model(c, access_grants=grants_map.get(c.id, []), db=db) for c in all_channels
+            ]
 
-    async def get_dm_channel_by_user_ids(self, user_ids: list[str], db: Optional[AsyncSession] = None) -> Optional[ChannelModel]:
+    async def get_dm_channel_by_user_ids(
+        self, user_ids: list[str], db: Optional[AsyncSession] = None
+    ) -> Optional[ChannelModel]:
         async with get_async_db_context(db) as db:
             # Ensure uniqueness in case a list with duplicates is passed
             unique_user_ids = list(set(user_ids))
@@ -462,9 +466,7 @@ async def add_members_to_channel(
             # 1. Collect all user_ids including groups + inviter
             requested_users = await self._collect_unique_user_ids(invited_by, user_ids, group_ids)
 
-            result = await db.execute(
-                select(ChannelMember.user_id).filter(ChannelMember.channel_id == channel_id)
-            )
+            result = await db.execute(select(ChannelMember.user_id).filter(ChannelMember.channel_id == channel_id))
             existing_users = {row[0] for row in result.all()}
 
             new_user_ids = requested_users - existing_users
@@ -512,7 +514,9 @@ async def is_user_channel_manager(self, channel_id: str, user_id: str, db: Optio
             membership = result.scalars().first()
             return membership is not None
 
-    async def join_channel(self, channel_id: str, user_id: str, db: Optional[AsyncSession] = None) -> Optional[ChannelMemberModel]:
+    async def join_channel(
+        self, channel_id: str, user_id: str, db: Optional[AsyncSession] = None
+    ) -> Optional[ChannelMemberModel]:
         async with get_async_db_context(db) as db:
             # Check if the membership already exists
             result = await db.execute(
@@ -581,11 +585,11 @@ async def get_member_by_channel_and_user_id(
             membership = result.scalars().first()
             return ChannelMemberModel.model_validate(membership) if membership else None
 
-    async def get_members_by_channel_id(self, channel_id: str, db: Optional[AsyncSession] = None) -> list[ChannelMemberModel]:
+    async def get_members_by_channel_id(
+        self, channel_id: str, db: Optional[AsyncSession] = None
+    ) -> list[ChannelMemberModel]:
         async with get_async_db_context(db) as db:
-            result = await db.execute(
-                select(ChannelMember).filter(ChannelMember.channel_id == channel_id)
-            )
+            result = await db.execute(select(ChannelMember).filter(ChannelMember.channel_id == channel_id))
             memberships = result.scalars().all()
             return [ChannelMemberModel.model_validate(membership) for membership in memberships]
 
@@ -613,7 +617,9 @@ async def pin_channel(
             await db.commit()
             return True
 
-    async def update_member_last_read_at(self, channel_id: str, user_id: str, db: Optional[AsyncSession] = None) -> bool:
+    async def update_member_last_read_at(
+        self, channel_id: str, user_id: str, db: Optional[AsyncSession] = None
+    ) -> bool:
         async with get_async_db_context(db) as db:
             result = await db.execute(
                 select(ChannelMember).filter(
@@ -658,11 +664,13 @@ async def update_member_active_status(
     async def is_user_channel_member(self, channel_id: str, user_id: str, db: Optional[AsyncSession] = None) -> bool:
         async with get_async_db_context(db) as db:
             result = await db.execute(
-                select(ChannelMember).filter(
+                select(ChannelMember)
+                .filter(
                     ChannelMember.channel_id == channel_id,
                     ChannelMember.user_id == user_id,
                     ChannelMember.is_active.is_(True),
-                ).limit(1)
+                )
+                .limit(1)
             )
             membership = result.scalars().first()
             return membership is not None
@@ -726,11 +734,13 @@ async def get_channels_by_file_id_and_user_id(
                 # --- Case A: group or dm => user must be an active member ---
                 if channel.type in ['group', 'dm']:
                     result = await db.execute(
-                        select(ChannelMember).filter(
+                        select(ChannelMember)
+                        .filter(
                             ChannelMember.channel_id == channel.id,
                             ChannelMember.user_id == user_id,
                             ChannelMember.is_active.is_(True),
-                        ).limit(1)
+                        )
+                        .limit(1)
                     )
                     membership = result.scalars().first()
                     if membership:
@@ -774,11 +784,13 @@ async def get_channel_by_id_and_user_id(
             # If the channel is a group or dm, read access requires membership (active)
             if channel.type in ['group', 'dm']:
                 result = await db.execute(
-                    select(ChannelMember).filter(
+                    select(ChannelMember)
+                    .filter(
                         ChannelMember.channel_id == id,
                         ChannelMember.user_id == user_id,
                         ChannelMember.is_active.is_(True),
-                    ).limit(1)
+                    )
+                    .limit(1)
                 )
                 membership = result.scalars().first()
                 if membership:
@@ -863,9 +875,7 @@ async def set_file_message_id_in_channel_by_id(
     ) -> bool:
         try:
             async with get_async_db_context(db) as db:
-                result = await db.execute(
-                    select(ChannelFile).filter_by(channel_id=channel_id, file_id=file_id)
-                )
+                result = await db.execute(select(ChannelFile).filter_by(channel_id=channel_id, file_id=file_id))
                 channel_file = result.scalars().first()
                 if not channel_file:
                     return False
@@ -878,7 +888,9 @@ async def set_file_message_id_in_channel_by_id(
         except Exception:
             return False
 
-    async def remove_file_from_channel_by_id(self, channel_id: str, file_id: str, db: Optional[AsyncSession] = None) -> bool:
+    async def remove_file_from_channel_by_id(
+        self, channel_id: str, file_id: str, db: Optional[AsyncSession] = None
+    ) -> bool:
         try:
             async with get_async_db_context(db) as db:
                 await db.execute(delete(ChannelFile).filter_by(channel_id=channel_id, file_id=file_id))
@@ -921,13 +933,17 @@ async def insert_webhook(
             await db.commit()
             return webhook
 
-    async def get_webhooks_by_channel_id(self, channel_id: str, db: Optional[AsyncSession] = None) -> list[ChannelWebhookModel]:
+    async def get_webhooks_by_channel_id(
+        self, channel_id: str, db: Optional[AsyncSession] = None
+    ) -> list[ChannelWebhookModel]:
         async with get_async_db_context(db) as db:
             result = await db.execute(select(ChannelWebhook).filter(ChannelWebhook.channel_id == channel_id))
             webhooks = result.scalars().all()
             return [ChannelWebhookModel.model_validate(w) for w in webhooks]
 
-    async def get_webhook_by_id(self, webhook_id: str, db: Optional[AsyncSession] = None) -> Optional[ChannelWebhookModel]:
+    async def get_webhook_by_id(
+        self, webhook_id: str, db: Optional[AsyncSession] = None
+    ) -> Optional[ChannelWebhookModel]:
         async with get_async_db_context(db) as db:
             result = await db.execute(select(ChannelWebhook).filter(ChannelWebhook.id == webhook_id))
             webhook = result.scalars().first()