com2ann

Author: asottile

src/flake8/__init__.py

@@ -62,7 +62,7 @@ def configure_logging(verbosity, filename=None, logformat=LOG_FORMAT):
 
     if not filename or filename in ("stderr", "stdout"):
         fileobj = getattr(sys, filename or "stderr")
-        handler_cls = logging.StreamHandler  # type: Type[logging.Handler]
+        handler_cls: Type[logging.Handler] = logging.StreamHandler
     else:
         fileobj = filename
         handler_cls = logging.FileHandler

src/flake8/api/legacy.py

@@ -81,7 +81,7 @@ def __init__(self, application):
         self._file_checker_manager = application.file_checker_manager
 
     @property
-    def options(self):  # type: () -> argparse.Namespace
+    def options(self) -> argparse.Namespace:
         """Return application's options.
 
         An instance of :class:`argparse.Namespace` containing parsed options.

src/flake8/checker.py

@@ -85,8 +85,8 @@ def __init__(self, style_guide, arguments, checker_plugins):
         self.options = style_guide.options
         self.checks = checker_plugins
         self.jobs = self._job_count()
-        self._all_checkers = []  # type: List[FileChecker]
-        self.checkers = []  # type: List[FileChecker]
+        self._all_checkers: List[FileChecker] = []
+        self.checkers: List[FileChecker] = []
         self.statistics = {
             "files": 0,
             "logical lines": 0,
@@ -103,8 +103,7 @@ def _process_statistics(self):
                 self.statistics[statistic] += checker.statistics[statistic]
         self.statistics["files"] += len(self.checkers)
 
-    def _job_count(self):
-        # type: () -> int
+    def _job_count(self) -> int:
         # First we walk through all of our error cases:
         # - multiprocessing library is not present
         # - we're running on windows in which case we know we have significant
@@ -165,8 +164,7 @@ def _handle_results(self, filename, results):
             )
         return reported_results_count
 
-    def is_path_excluded(self, path):
-        # type: (str) -> bool
+    def is_path_excluded(self, path: str) -> bool:
         """Check if a path is excluded.
 
         :param str path:
@@ -189,8 +187,7 @@ def is_path_excluded(self, path):
             logger=LOG,
         )
 
-    def make_checkers(self, paths=None):
-        # type: (Optional[List[str]]) -> None
+    def make_checkers(self, paths: Optional[List[str]] = None) -> None:
         """Create checkers for each file."""
         if paths is None:
             paths = self.arguments
@@ -235,8 +232,7 @@ def should_create_file_checker(filename, argument):
         self.checkers = [c for c in self._all_checkers if c.should_process]
         LOG.info("Checking %d files", len(self.checkers))
 
-    def report(self):
-        # type: () -> Tuple[int, int]
+    def report(self) -> Tuple[int, int]:
         """Report all of the errors found in the managed file checkers.
 
         This iterates over each of the checkers and reports the errors sorted
@@ -258,11 +254,11 @@ def report(self):
             results_found += len(results)
         return (results_found, results_reported)
 
-    def run_parallel(self):  # type: () -> None
+    def run_parallel(self) -> None:
         """Run the checkers in parallel."""
         # fmt: off
-        final_results = collections.defaultdict(list)  # type: Dict[str, List[Tuple[str, int, int, str, Optional[str]]]]  # noqa: E501
-        final_statistics = collections.defaultdict(dict)  # type: Dict[str, Dict[str, int]]  # noqa: E501
+        final_results: Dict[str, List[Tuple[str, int, int, str, Optional[str]]]] = collections.defaultdict(list)  # noqa: E501
+        final_statistics: Dict[str, Dict[str, int]] = collections.defaultdict(dict)  # noqa: E501
         # fmt: on
 
         pool = _try_initialize_processpool(self.jobs)
@@ -297,12 +293,12 @@ def run_parallel(self):  # type: () -> None
             checker.results = final_results[filename]
             checker.statistics = final_statistics[filename]
 
-    def run_serial(self):  # type: () -> None
+    def run_serial(self) -> None:
         """Run the checkers in serial."""
         for checker in self.checkers:
             checker.run_checks()
 
-    def run(self):  # type: () -> None
+    def run(self) -> None:
         """Run all the checkers.
 
         This will intelligently decide whether to run the checks in parallel
@@ -356,9 +352,7 @@ def __init__(self, filename, checks, options):
         self.options = options
         self.filename = filename
         self.checks = checks
-        # fmt: off
-        self.results = []  # type: List[Tuple[str, int, int, str, Optional[str]]]  # noqa: E501
-        # fmt: on
+        self.results: List[Tuple[str, int, int, str, Optional[str]]] = []
         self.statistics = {
             "tokens": 0,
             "logical lines": 0,
@@ -372,12 +366,11 @@ def __init__(self, filename, checks, options):
             self.should_process = not self.processor.should_ignore_file()
             self.statistics["physical lines"] = len(self.processor.lines)
 
-    def __repr__(self):  # type: () -> str
+    def __repr__(self) -> str:
         """Provide helpful debugging representation."""
         return f"FileChecker for {self.filename}"
 
-    def _make_processor(self):
-        # type: () -> Optional[processor.FileProcessor]
+    def _make_processor(self) -> Optional[processor.FileProcessor]:
         try:
             return processor.FileProcessor(self.filename, self.options)
         except OSError as e:
@@ -391,8 +384,13 @@ def _make_processor(self):
             self.report("E902", 0, 0, message)
             return None
 
-    def report(self, error_code, line_number, column, text):
-        # type: (Optional[str], int, int, str) -> str
+    def report(
+        self,
+        error_code: Optional[str],
+        line_number: int,
+        column: int,
+        text: str,
+    ) -> str:
         """Report an error by storing it in the results list."""
         if error_code is None:
             error_code, text = text.split(" ", 1)
@@ -468,7 +466,7 @@ def _extract_syntax_information(exception):
             column -= column_offset
         return row, column
 
-    def run_ast_checks(self):  # type: () -> None
+    def run_ast_checks(self) -> None:
         """Run all checks expecting an abstract syntax tree."""
         try:
             ast = self.processor.build_ast()
@@ -610,8 +608,9 @@ def handle_newline(self, token_type):
         else:
             self.run_logical_checks()
 
-    def check_physical_eol(self, token, prev_physical):
-        # type: (processor._Token, str) -> None
+    def check_physical_eol(
+        self, token: processor._Token, prev_physical: str
+    ) -> None:
         """Run physical checks if and only if it is at the end of the line."""
         # a newline token ends a single physical line.
         if processor.is_eol_token(token):
@@ -640,13 +639,14 @@ def check_physical_eol(self, token, prev_physical):
                     self.run_physical_checks(line + "\n")
 
 
-def _pool_init():  # type: () -> None
+def _pool_init() -> None:
     """Ensure correct signaling of ^C using multiprocessing.Pool."""
     signal.signal(signal.SIGINT, signal.SIG_IGN)
 
 
-def _try_initialize_processpool(job_count):
-    # type: (int) -> Optional[multiprocessing.pool.Pool]
+def _try_initialize_processpool(
+    job_count: int,
+) -> Optional[multiprocessing.pool.Pool]:
     """Return a new process pool instance if we are able to create one."""
     try:
         return multiprocessing.Pool(job_count, _pool_init)
@@ -675,8 +675,9 @@ def _run_checks(checker):
     return checker.run_checks()
 
 
-def find_offset(offset, mapping):
-    # type: (int, processor._LogicalMapping) -> Tuple[int, int]
+def find_offset(
+    offset: int, mapping: processor._LogicalMapping
+) -> Tuple[int, int]:
     """Find the offset tuple for a single offset."""
     if isinstance(offset, tuple):
         return offset

src/flake8/exceptions.py

@@ -19,14 +19,13 @@ class FailedToLoadPlugin(Flake8Exception):
 
     FORMAT = 'Flake8 failed to load plugin "%(name)s" due to %(exc)s.'
 
-    def __init__(self, plugin_name, exception):
-        # type: (str, Exception) -> None
+    def __init__(self, plugin_name: str, exception: Exception) -> None:
         """Initialize our FailedToLoadPlugin exception."""
         self.plugin_name = plugin_name
         self.original_exception = exception
         super().__init__(plugin_name, exception)
 
-    def __str__(self):  # type: () -> str
+    def __str__(self) -> str:
         """Format our exception message."""
         return self.FORMAT % {
             "name": self.plugin_name,
@@ -37,7 +36,7 @@ def __str__(self):  # type: () -> str
 class InvalidSyntax(Flake8Exception):
     """Exception raised when tokenizing a file fails."""
 
-    def __init__(self, exception):  # type: (Exception) -> None
+    def __init__(self, exception: Exception) -> None:
         """Initialize our InvalidSyntax exception."""
         self.original_exception = exception
         self.error_message = "{}: {}".format(
@@ -48,7 +47,7 @@ def __init__(self, exception):  # type: (Exception) -> None
         self.column_number = 0
         super().__init__(exception)
 
-    def __str__(self):  # type: () -> str
+    def __str__(self) -> str:
         """Format our exception message."""
         return self.error_message
 
@@ -58,14 +57,13 @@ class PluginRequestedUnknownParameters(Flake8Exception):
 
     FORMAT = '"%(name)s" requested unknown parameters causing %(exc)s'
 
-    def __init__(self, plugin, exception):
-        # type: (Dict[str, str], Exception) -> None
+    def __init__(self, plugin: Dict[str, str], exception: Exception) -> None:
         """Pop certain keyword arguments for initialization."""
         self.plugin = plugin
         self.original_exception = exception
         super().__init__(plugin, exception)
 
-    def __str__(self):  # type: () -> str
+    def __str__(self) -> str:
         """Format our exception message."""
         return self.FORMAT % {
             "name": self.plugin["plugin_name"],
@@ -78,14 +76,13 @@ class PluginExecutionFailed(Flake8Exception):
 
     FORMAT = '"%(name)s" failed during execution due to "%(exc)s"'
 
-    def __init__(self, plugin, exception):
-        # type: (Dict[str, str], Exception) -> None
+    def __init__(self, plugin: Dict[str, str], exception: Exception) -> None:
         """Utilize keyword arguments for message generation."""
         self.plugin = plugin
         self.original_exception = exception
         super().__init__(plugin, exception)
 
-    def __str__(self):  # type: () -> str
+    def __str__(self) -> str:
         """Format our exception message."""
         return self.FORMAT % {
             "name": self.plugin["plugin_name"],

src/flake8/formatting/base.py

@@ -33,8 +33,7 @@ class BaseFormatter:
         output filename has been specified.
     """
 
-    def __init__(self, options):
-        # type: (argparse.Namespace) -> None
+    def __init__(self, options: argparse.Namespace) -> None:
         """Initialize with the options parsed from config and cli.
 
         This also calls a hook, :meth:`after_init`, so subclasses do not need
@@ -48,38 +47,38 @@ def __init__(self, options):
         """
         self.options = options
         self.filename = options.output_file
-        self.output_fd = None  # type: Optional[IO[str]]
+        self.output_fd: Optional[IO[str]] = None
         self.newline = "\n"
         self.after_init()
 
-    def after_init(self):  # type: () -> None
+    def after_init(self) -> None:
         """Initialize the formatter further."""
 
-    def beginning(self, filename):  # type: (str) -> None
+    def beginning(self, filename: str) -> None:
         """Notify the formatter that we're starting to process a file.
 
         :param str filename:
             The name of the file that Flake8 is beginning to report results
             from.
         """
 
-    def finished(self, filename):  # type: (str) -> None
+    def finished(self, filename: str) -> None:
         """Notify the formatter that we've finished processing a file.
 
         :param str filename:
             The name of the file that Flake8 has finished reporting results
             from.
         """
 
-    def start(self):  # type: () -> None
+    def start(self) -> None:
         """Prepare the formatter to receive input.
 
         This defaults to initializing :attr:`output_fd` if :attr:`filename`
         """
         if self.filename:
             self.output_fd = open(self.filename, "a")
 
-    def handle(self, error):  # type: (Violation) -> None
+    def handle(self, error: "Violation") -> None:
         """Handle an error reported by Flake8.
 
         This defaults to calling :meth:`format`, :meth:`show_source`, and
@@ -96,7 +95,7 @@ def handle(self, error):  # type: (Violation) -> None
         source = self.show_source(error)
         self.write(line, source)
 
-    def format(self, error):  # type: (Violation) -> Optional[str]
+    def format(self, error: "Violation") -> Optional[str]:
         """Format an error reported by Flake8.
 
         This method **must** be implemented by subclasses.
@@ -115,7 +114,7 @@ def format(self, error):  # type: (Violation) -> Optional[str]
             "Subclass of BaseFormatter did not implement" " format."
         )
 
-    def show_statistics(self, statistics):  # type: (Statistics) -> None
+    def show_statistics(self, statistics: "Statistics") -> None:
         """Format and print the statistics."""
         for error_code in statistics.error_codes():
             stats_for_error_code = statistics.statistics_for(error_code)
@@ -130,8 +129,7 @@ def show_statistics(self, statistics):  # type: (Statistics) -> None
                 )
             )
 
-    def show_benchmarks(self, benchmarks):
-        # type: (List[Tuple[str, float]]) -> None
+    def show_benchmarks(self, benchmarks: List[Tuple[str, float]]) -> None:
         """Format and print the benchmarks."""
         # NOTE(sigmavirus24): The format strings are a little confusing, even
         # to me, so here's a quick explanation:
@@ -152,7 +150,7 @@ def show_benchmarks(self, benchmarks):
                 benchmark = float_format(statistic=statistic, value=value)
             self._write(benchmark)
 
-    def show_source(self, error):  # type: (Violation) -> Optional[str]
+    def show_source(self, error: "Violation") -> Optional[str]:
         """Show the physical line generating the error.
 
         This also adds an indicator for the particular part of the line that
@@ -183,15 +181,14 @@ def show_source(self, error):  # type: (Violation) -> Optional[str]
         # one
         return f"{error.physical_line}{indent}^"
 
-    def _write(self, output):  # type: (str) -> None
+    def _write(self, output: str) -> None:
         """Handle logic of whether to use an output file or print()."""
         if self.output_fd is not None:
             self.output_fd.write(output + self.newline)
         if self.output_fd is None or self.options.tee:
             print(output, end=self.newline)
 
-    def write(self, line, source):
-        # type: (Optional[str], Optional[str]) -> None
+    def write(self, line: Optional[str], source: Optional[str]) -> None:
         """Write the line either to the output file or stdout.
 
         This handles deciding whether to write to a file or print to standard
@@ -209,7 +206,7 @@ def write(self, line, source):
         if source:
             self._write(source)
 
-    def stop(self):  # type: () -> None
+    def stop(self) -> None:
         """Clean up after reporting is finished."""
         if self.output_fd is not None:
             self.output_fd.close()