eric: comparison src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Annotations/AnnotationsChecker.py

-:1a7d545d3ef2
+:e6748a5e24b9
 """
 Module implementing a checker for function type annotations.
 """
+import ast
+import contextlib
 import copy
-import ast
 import sys
 from functools import lru_cache
 import AstUtilities
 "A204",
 "A205",
 "A206",
 ## Mixed kind of annotations
 "A301",
+## Dynamically typed annotations
+"A401",
 ## Annotations Future
 "A871",
+"A872",
 ## Annotation Coverage
 "A881",
 ## Annotation Complexity
 "A891",
 "A892",
 "A203",
 "A204",
 "A205",
 "A206",
 "A301",
+"A401",
 ),
 ),
-(self.__checkAnnotationsFuture, ("A871",)),
+(self.__checkAnnotationsFuture, ("A871", "A872")),
 (self.__checkAnnotationsCoverage, ("A881",)),
 (self.__checkAnnotationComplexity, ("A891", "A892")),
 ]
 self.__checkers = []
 check()
 #######################################################################
 ## Annotations
 ##
-## adapted from: flake8-annotations v2.7.0
+## adapted from: flake8-annotations v2.9.0
 #######################################################################
-# TODO: update to v2.9.0
 def __checkFunctionAnnotations(self):
 """
 Private method to check for function annotation issues.
 """
 allowUntypedNested = self.__args.get(
 "AllowUntypedNested", AnnotationsCheckerDefaultArgs["AllowUntypedNested"]
 )
 mypyInitReturn = self.__args.get(
 "MypyInitReturn", AnnotationsCheckerDefaultArgs["MypyInitReturn"]
+)
+allowStarArgAny = self.__args.get(
+"AllowStarArgAny", AnnotationsCheckerDefaultArgs["AllowStarArgAny"]
 )
 # Store decorator lists as sets for easier lookup
 dispatchDecorators = set(
 self.__args.get(
 hasTypeComment = function.hasTypeComment
 has3107Annotation = False
 # PEP 3107 annotations are captured by the return arg
+annotatedArgs = function.getAnnotatedArguments()
 # Iterate over annotated args to detect mixing of type annotations
 # and type comments. Emit this only once per function definition
-for arg in function.getAnnotatedArguments():
+for arg in annotatedArgs:
 if arg.hasTypeComment:
 hasTypeComment = True
 if arg.has3107Annotation:
 has3107Annotation = True
 if hasTypeComment and has3107Annotation:
 # Short-circuit check for mixing of type comments &
 # 3107-style annotations
 self.__error(function.lineno - 1, function.col_offset, "A301")
 break
+# Iterate over the annotated args to look for 'typing.Any' annotations
+# We could combine this with the above loop but I'd rather not add even
+# more sentinels unless we'd notice a significant enough performance impact
+for arg in annotatedArgs:
+if arg.isDynamicallyTyped:
+if allowStarArgAny and arg.annotationType in {
+AnnotationType.VARARG,
+AnnotationType.KWARG,
+}:
+continue
+self.__error(function.lineno - 1, function.col_offset, "A401")
 # Before we iterate over the function's missing annotations, check
 # to see if it's the closing function def in a series of
 # `typing.overload` decorated functions.
 if lastOverloadDecoratedFunctionName == function.name:
 if (
 mypyInitReturn
 and function.isClassMethod
 and function.name == "__init__"
-and function.getAnnotatedArguments()
+and annotatedArgs
 ):
 # Skip recording return errors for `__init__` if at
 # least one argument is annotated
 continue
 return "A001"
 #######################################################################
 ## Annotations Coverage
 ##
-## adapted from: flake8-annotations-coverage v0.0.5
+## adapted from: flake8-annotations-coverage v0.0.6
 #######################################################################
-# TODO: update to v0.0.6
 def __checkAnnotationsCoverage(self):
 """
 Private method to check for function annotation coverage.
 """
 return
 functionDefAnnotationsInfo = [
 self.__hasTypeAnnotations(f) for f in functionDefs
 ]
+if not bool(functionDefAnnotationsInfo):
+return
 annotationsCoverage = int(
 len(list(filter(None, functionDefAnnotationsInfo)))
 / len(functionDefAnnotationsInfo)
 * 100
 )
 )
 #######################################################################
 ## Annotations Complexity
 ##
-## adapted from: flake8-annotations-complexity v0.0.6
+## adapted from: flake8-annotations-complexity v0.0.7
 #######################################################################
-# TODO: update to v0.0.7
 def __checkAnnotationComplexity(self):
 """
 Private method to check the type annotation complexity.
 """
 for f in ast.walk(self.__tree)
 if isinstance(f, (ast.AsyncFunctionDef, ast.FunctionDef))
 ]
 for functionDef in functionDefs:
 typeAnnotations += list(
-filter(None, [a.annotation for a in functionDef.args.args])
+filter(None, (a.annotation for a in functionDef.args.args))
 )
 if functionDef.returns:
 typeAnnotations.append(functionDef.returns)
 typeAnnotations += [
 a.annotation
 if AstUtilities.isString(annotationNode):
 try:
 annotationNode = ast.parse(annotationNode.s).body[0].value
 except (SyntaxError, IndexError):
 return defaultComplexity
+complexity = defaultComplexity
 if isinstance(annotationNode, ast.Subscript):
 if sys.version_info >= (3, 9):
-return defaultComplexity + self.__getAnnotationComplexity(
+complexity = defaultComplexity + self.__getAnnotationComplexity(
 annotationNode.slice
 )
 else:
-return defaultComplexity + self.__getAnnotationComplexity(
+complexity = defaultComplexity + self.__getAnnotationComplexity(
 annotationNode.slice.value
 )
 if isinstance(annotationNode, ast.Tuple):
-return max(
+complexity = max(
 (self.__getAnnotationComplexity(n) for n in annotationNode.elts),
 default=defaultComplexity,
 )
-return defaultComplexity
+return complexity
 def __getAnnotationLength(self, annotationNode):
 """
 Private method to determine the annotation length.
 length for
 @type ast.AST
 @return annotation length
 @rtype = int
 """
+annotationLength = 0
 if AstUtilities.isString(annotationNode):
 try:
 annotationNode = ast.parse(annotationNode.s).body[0].value
 except (SyntaxError, IndexError):
-return 0
+return annotationLength
 if isinstance(annotationNode, ast.Subscript):
-try:
+with contextlib.suppress(AttributeError):
-if sys.version_info >= (3, 9):
+annotationLength = (
-return len(annotationNode.slice.elts)
+len(annotationNode.slice.elts)
-else:
+if sys.version_info >= (3, 9)
-return len(annotationNode.slice.value.elts)
+else len(annotationNode.slice.value.elts)
-except AttributeError:
+)
-return 0
-return 0
+return annotationLength
 #######################################################################
 ## 'from __future__ import annotations' checck
 ##
-## adapted from: flake8-future-annotations v0.0.4
+## adapted from: flake8-future-annotations v0.0.5
 #######################################################################
-# TODO: update to v0.0.5
 def __checkAnnotationsFuture(self):
 """
 Private method to check the use of __future__ and typing imports.
 """
 from .AnnotationsFutureVisitor import AnnotationsFutureVisitor
+forceFutureAnnotations = self.__args.get(
+"ForceFutureAnnotations",
+AnnotationsCheckerDefaultArgs["ForceFutureAnnotations"],
+)
 visitor = AnnotationsFutureVisitor()
 visitor.visit(self.__tree)
-if visitor.importsFutureAnnotations() or not visitor.hasTypingImports():
+if visitor.importsFutureAnnotations():
 return
-imports = ", ".join(visitor.getTypingImports())
+if visitor.hasTypingImports():
-self.__error(0, 0, "A871", imports)
+imports = ", ".join(visitor.getTypingImports())
+self.__error(0, 0, "A871", imports)
+elif forceFutureAnnotations:
+self.__error(0, 0, "A872")

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Annotations/AnnotationsChecker.py

src/eric7/Plugins/CheckerPlugins/CodeStyleChecker/Annotations/AnnotationsChecker.py