[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

mypy/plugins/functools.py

@@ -400,27 +400,28 @@ def functools_lru_cache_callback(ctx: mypy.plugin.FunctionContext) -> Type:
     """Infer a more precise return type for functools.lru_cache decorator"""
     if not isinstance(ctx.api, mypy.checker.TypeChecker):  # use internals
         return ctx.default_return_type
-    
+
     # Only handle the simple case: @lru_cache (without parentheses)
     # where a function is passed directly as the first argument
-    if (len(ctx.arg_types) >= 1 and 
-        len(ctx.arg_types[0]) == 1 and
-        len(ctx.arg_types) <= 2):  # Ensure we don't have extra args indicating parameterized call
-        
+    if (
+        len(ctx.arg_types) >= 1 and len(ctx.arg_types[0]) == 1 and len(ctx.arg_types) <= 2
+    ):  # Ensure we don't have extra args indicating parameterized call
+
         first_arg_type = ctx.arg_types[0][0]
-        
+
         # Explicitly check that this is NOT a literal or other non-function type
-        from mypy.types import LiteralType, Instance
+        from mypy.types import Instance, LiteralType
+
         if isinstance(first_arg_type, (LiteralType, Instance)):
             # This is likely maxsize=128 or similar - let MyPy handle it
             return ctx.default_return_type
-        
+
         # Try to extract callable type
         fn_type = ctx.api.extract_callable_type(first_arg_type, ctx=ctx.default_return_type)
         if fn_type is not None:
             # This is the @lru_cache case (function passed directly)
             return fn_type
-    
+
     # For all parameterized cases, don't interfere
     return ctx.default_return_type
 
@@ -429,17 +430,17 @@ def lru_cache_wrapper_call_callback(ctx: mypy.plugin.MethodContext) -> Type:
     """Handle calls to functools._lru_cache_wrapper objects to provide parameter validation"""
     if not isinstance(ctx.api, mypy.checker.TypeChecker):
         return ctx.default_return_type
-    
+
     # Try to find the original function signature using AST/symbol table analysis
     original_signature = _find_original_function_signature(ctx)
-    
+
     if original_signature is not None:
         # Validate the call against the original function signature
         actual_args = []
         actual_arg_kinds = []
         actual_arg_names = []
         seen_args = set()
-        
+
         for i, param in enumerate(ctx.args):
             for j, a in enumerate(param):
                 if a in seen_args:
@@ -458,55 +459,55 @@ def lru_cache_wrapper_call_callback(ctx: mypy.plugin.MethodContext) -> Type:
             context=ctx.context,
         )
         return result
-    
+
     return ctx.default_return_type
 
 
 def _find_original_function_signature(ctx: mypy.plugin.MethodContext) -> CallableType | None:
     """
     Attempt to find the original function signature from the call context.
-    
+
     Returns the CallableType of the original function if found, None otherwise.
     This function safely traverses the AST structure to locate the original
     function signature that was decorated with @lru_cache.
     """
     from mypy.nodes import CallExpr, Decorator, NameExpr
-    
+
     # Ensure we have the required context structure
     if not isinstance(ctx.context, CallExpr):
         return None
-    
+
     callee = ctx.context.callee
     if not isinstance(callee, NameExpr) or not callee.name:
         return None
-    
+
     func_name = callee.name
-    
+
     # Safely access the API globals
-    if not hasattr(ctx.api, 'globals') or not isinstance(ctx.api.globals, dict):
+    if not hasattr(ctx.api, "globals") or not isinstance(ctx.api.globals, dict):
         return None
-    
+
     if func_name not in ctx.api.globals:
         return None
-    
+
     symbol = ctx.api.globals[func_name]
-    
+
     # Validate symbol structure before accessing node
-    if not hasattr(symbol, 'node') or symbol.node is None:
+    if not hasattr(symbol, "node") or symbol.node is None:
         return None
-    
+
     # Check if this is a decorator node containing our function
     if isinstance(symbol.node, Decorator):
         decorator_node = symbol.node
-        
+
         # Safely access the decorated function
-        if not hasattr(decorator_node, 'func') or decorator_node.func is None:
+        if not hasattr(decorator_node, "func") or decorator_node.func is None:
             return None
-        
+
         func_def = decorator_node.func
-        
+
         # Verify we have a callable type
-        if hasattr(func_def, 'type') and isinstance(func_def.type, CallableType):
+        if hasattr(func_def, "type") and isinstance(func_def.type, CallableType):
             return func_def.type
-    
+
     return None