Fix lint

Author: shangyian

datajunction-server/datajunction_server/construction/build_v2.py

@@ -287,8 +287,8 @@ async def create(
     ) -> "QueryBuilder":
         """
         Create a QueryBuilder instance for the node revision.
-        
-        Note: If the node was loaded with Node.get_by_name_eager(), 
+
+        Note: If the node was loaded with Node.get_by_name_eager(),
         required_dimensions and dimension_links will already be loaded.
         """
         # Only refresh if not already loaded (i.e., not from eager loading)
@@ -298,7 +298,7 @@ async def create(
             links_loaded = True
         except:  # noqa: E722
             links_loaded = False
-            
+
         if not links_loaded:
             await refresh_if_needed(
                 session,
@@ -479,14 +479,14 @@ async def build(self) -> ast.Query:
             columns_loaded = True
         except:  # noqa: E722
             columns_loaded = False
-            
+
         if not columns_loaded:
             await refresh_if_needed(
                 self.session,
                 self.node_revision,
                 ["availability", "columns", "query_ast"],
             )
-        
+
         if self.node_revision.query_ast:
             node_ast = self.node_revision.query_ast  # pragma: no cover
         else:

datajunction-server/datajunction_server/database/node.py

@@ -524,39 +524,43 @@ async def get_by_name_eager(
     ) -> Optional["Node"]:
         """
         Get a node by name with eager loading to minimize database queries.
-        
+
         This method loads all commonly needed relationships in 1-2 queries instead
         of the N+1 pattern that happens with lazy loading. This significantly speeds
         up query building by eliminating redundant database round trips.
-        
+
         Args:
             session: Database session
             name: Node name
             load_dimensions: Whether to eagerly load dimension links and their targets
             load_parents: Whether to eagerly load parent node relationships
             raise_if_not_exists: Whether to raise exception if node not found
-            
+
         Returns:
             Node with all relationships eagerly loaded, or None if not found
-            
+
         Example:
             >>> node = await Node.get_by_name_eager(session, "default.revenue", load_dimensions=True)
             >>> # All columns, dimension_links, availability already loaded - no extra queries!
             >>> columns = node.current.columns  # Already loaded
             >>> links = node.current.dimension_links  # Already loaded
         """
         from datajunction_server.database.dimensionlink import DimensionLink
-        
+
         # Build base query
-        statement = select(Node).where(Node.name == name).where(is_(Node.deactivated_at, None))
-        
+        statement = (
+            select(Node).where(Node.name == name).where(is_(Node.deactivated_at, None))
+        )
+
         # Eagerly load current revision with all its relationships
         options = [
             joinedload(Node.current).options(
                 # Load columns with their attributes
                 selectinload(NodeRevision.columns).options(
                     selectinload(Column.attributes),
-                    joinedload(Column.dimension),  # Load dimension references on columns
+                    joinedload(
+                        Column.dimension,
+                    ),  # Load dimension references on columns
                 ),
                 # Load availability state
                 joinedload(NodeRevision.availability),
@@ -574,11 +578,13 @@ async def get_by_name_eager(
             selectinload(Node.created_by),
             selectinload(Node.owners),
         ]
-        
+
         # Optionally load dimension links (common for query building with dimensions)
         if load_dimensions:
             options.append(
-                joinedload(Node.current).selectinload(NodeRevision.dimension_links).options(
+                joinedload(Node.current)
+                .selectinload(NodeRevision.dimension_links)
+                .options(
                     # Load the target dimension node
                     joinedload(DimensionLink.dimension).options(
                         # Load dimension's current revision
@@ -589,31 +595,33 @@ async def get_by_name_eager(
                             joinedload(NodeRevision.availability),
                         ),
                     ),
-                )
+                ),
             )
-        
+
         # Optionally load parent nodes (for building upstream references)
         if load_parents:
             options.append(
-                joinedload(Node.current).selectinload(NodeRevision.parents).options(
+                joinedload(Node.current)
+                .selectinload(NodeRevision.parents)
+                .options(
                     joinedload(Node.current).options(
                         selectinload(NodeRevision.columns),
                         joinedload(NodeRevision.availability),
                     ),
-                )
+                ),
             )
-        
+
         statement = statement.options(*options)
-        
+
         result = await session.execute(statement)
         node = result.unique().scalar_one_or_none()
-        
+
         if not node and raise_if_not_exists:
             raise DJNodeNotFound(
                 message=f"Node `{name}` does not exist.",
                 http_status_code=404,
             )
-        
+
         return node
 
     @classmethod

datajunction-server/datajunction_server/internal/sql.py

@@ -67,16 +67,17 @@ async def build_node_sql(
     Build node SQL and save it to query requests
     """
     import time
+
     start_time = time.time()
-    
+
     if orderby:
         validate_orderby(orderby, [node_name], dimensions or [])
 
     # Use eager loading to minimize database queries
     node = cast(
         Node,
         await Node.get_by_name_eager(
-            session, 
+            session,
             node_name,
             load_dimensions=bool(dimensions),  # Only load if we need dimensions
             load_parents=True,  # Always load for upstream references
@@ -155,7 +156,7 @@ async def build_node_sql(
         columns=columns,
         dialect=engine.dialect if engine else None,
     )
-    
+
     # Log timing
     build_time = (time.time() - start_time) * 1000
     logger.info(
@@ -164,7 +165,7 @@ async def build_node_sql(
         len(dimensions or []),
         build_time,
     )
-    
+
     return result