Reformat according to format-incremental

Author: mhucka

dev_tools/env_tools.py

@@ -40,8 +40,9 @@ def get_unhidden_ungenerated_python_files(directory: str) -> Iterable[str]:
                 yield os.path.join(dirpath, filename)
 
 
-def create_virtual_env(venv_path: str, requirements_paths: Iterable[str],
-                       python_path: str, verbose: bool) -> None:
+def create_virtual_env(
+    venv_path: str, requirements_paths: Iterable[str], python_path: str, verbose: bool
+) -> None:
     """Creates a new virtual environment and then installs dependencies.
 
     Args:
@@ -50,30 +51,24 @@ def create_virtual_env(venv_path: str, requirements_paths: Iterable[str],
         python_path: The python binary to use.
         verbose: When set, more progress output is produced.
     """
-    shell_tools.run_cmd('virtualenv',
-                        None if verbose else '--quiet',
-                        '-p',
-                        python_path,
-                        venv_path,
-                        out=sys.stderr)
+    shell_tools.run_cmd(
+        'virtualenv', None if verbose else '--quiet', '-p', python_path, venv_path, out=sys.stderr
+    )
     pip_path = os.path.join(venv_path, 'bin', 'pip')
     for req_path in requirements_paths:
-        shell_tools.run_cmd(pip_path,
-                            'install',
-                            None if verbose else '--quiet',
-                            '-r',
-                            req_path,
-                            out=sys.stderr)
+        shell_tools.run_cmd(
+            pip_path, 'install', None if verbose else '--quiet', '-r', req_path, out=sys.stderr
+        )
 
 
 def prepare_temporary_test_environment(
-        destination_directory: str,
-        repository: GithubRepository,
-        pull_request_number: Optional[int],
-        verbose: bool,
-        env_name: str = '.test_virtualenv',
-        python_path: str = sys.executable,
-        commit_ids_known_callback: Callable[[PreparedEnv], None] = None
+    destination_directory: str,
+    repository: GithubRepository,
+    pull_request_number: Optional[int],
+    verbose: bool,
+    env_name: str = '.test_virtualenv',
+    python_path: str = sys.executable,
+    commit_ids_known_callback: Callable[[PreparedEnv], None] = None,
 ) -> PreparedEnv:
     """Prepares a temporary test environment at the (existing empty) directory.
 
@@ -101,10 +96,12 @@ def prepare_temporary_test_environment(
             destination_directory=destination_directory,
             repository=repository,
             pull_request_number=pull_request_number,
-            verbose=verbose)
+            verbose=verbose,
+        )
     else:
         env = git_env_tools.fetch_local_files(
-            destination_directory=destination_directory, verbose=verbose)
+            destination_directory=destination_directory, verbose=verbose
+        )
 
     if commit_ids_known_callback is not None:
         commit_ids_known_callback(env)
@@ -113,18 +110,19 @@ def prepare_temporary_test_environment(
     base_path = cast(str, env.destination_directory)
     env_path = os.path.join(base_path, env_name)
     req_path = os.path.join(base_path, 'tutorial-requirements.txt')
-    dev_req_path = os.path.join(base_path, 'dev_tools', 'conf',
-                                'pip-list-dev-tools.txt')
-    contrib_req_path = os.path.join(base_path, 'cirq', 'contrib',
-                                    'contrib-tutorial-requirements.txt')
+    dev_req_path = os.path.join(base_path, 'dev_tools', 'conf', 'pip-list-dev-tools.txt')
+    contrib_req_path = os.path.join(
+        base_path, 'cirq', 'contrib', 'contrib-tutorial-requirements.txt'
+    )
     rev_paths = [req_path, dev_req_path, contrib_req_path]
-    create_virtual_env(venv_path=env_path,
-                       python_path=python_path,
-                       requirements_paths=rev_paths,
-                       verbose=verbose)
-
-    return PreparedEnv(github_repo=env.repository,
-                       actual_commit_id=env.actual_commit_id,
-                       compare_commit_id=env.compare_commit_id,
-                       destination_directory=env.destination_directory,
-                       virtual_env_path=env_path)
+    create_virtual_env(
+        venv_path=env_path, python_path=python_path, requirements_paths=rev_paths, verbose=verbose
+    )
+
+    return PreparedEnv(
+        github_repo=env.repository,
+        actual_commit_id=env.actual_commit_id,
+        compare_commit_id=env.compare_commit_id,
+        destination_directory=env.destination_directory,
+        virtual_env_path=env_path,
+    )

dev_tools/github_repository.py

@@ -18,8 +18,7 @@
 class GithubRepository:
     """Details how to access a repository on github."""
 
-    def __init__(self, organization: str, name: str,
-                 access_token: Optional[str]) -> None:
+    def __init__(self, organization: str, name: str, access_token: Optional[str]) -> None:
         """
         Args:
             organization: The github organization the repository is under.

dev_tools/incremental_coverage.py

@@ -50,8 +50,7 @@
 EXPLICIT_OPT_OUT_COMMENT = '#coverage:ignore'
 
 
-def diff_to_new_interesting_lines(unified_diff_lines: List[str]
-                                 ) -> Dict[int, str]:
+def diff_to_new_interesting_lines(unified_diff_lines: List[str]) -> Dict[int, str]:
     """
     Extracts a set of 'interesting' lines out of a GNU unified diff format.
 
@@ -95,7 +94,7 @@ def diff_to_new_interesting_lines(unified_diff_lines: List[str]
         # Parse the 'new file' range parts of the unified diff.
         if not diff_line.startswith('@@ '):
             continue
-        change = diff_line[3:diff_line.index(' @@', 3)]
+        change = diff_line[3 : diff_line.index(' @@', 3)]
         new = change.split(' ')[1]
         start = int(new.split(',')[0])
         count = 1 if ',' not in new else int(new.split(',')[1])
@@ -117,9 +116,9 @@ def fix_line_from_coverage_file(line):
     return line
 
 
-def get_incremental_uncovered_lines(abs_path: str, base_commit: str,
-                                    actual_commit: Optional[str]
-                                   ) -> List[Tuple[int, str, str]]:
+def get_incremental_uncovered_lines(
+    abs_path: str, base_commit: str, actual_commit: Optional[str]
+) -> List[Tuple[int, str, str]]:
     """
     Uses git diff and the annotation files created by
     `pytest --cov-report annotate` to find touched but uncovered lines in the
@@ -139,12 +138,10 @@ def get_incremental_uncovered_lines(abs_path: str, base_commit: str,
     if not os.path.isfile(abs_path):
         return []
 
-    unified_diff_lines_str = shell_tools.output_of('git', 'diff', '--unified=0',
-                                                   base_commit, actual_commit,
-                                                   '--', abs_path)
-    unified_diff_lines = [
-        e for e in unified_diff_lines_str.split('\n') if e.strip()
-    ]
+    unified_diff_lines_str = shell_tools.output_of(
+        'git', 'diff', '--unified=0', base_commit, actual_commit, '--', abs_path
+    )
+    unified_diff_lines = [e for e in unified_diff_lines_str.split('\n') if e.strip()]
 
     touched_lines = diff_to_new_interesting_lines(unified_diff_lines)
 
@@ -155,10 +152,12 @@ def get_incremental_uncovered_lines(abs_path: str, base_commit: str,
     has_cover_file = os.path.isfile(cover_path)
     content_file = cover_path if has_cover_file else abs_path
     with open(content_file, 'r') as annotated_coverage_file:
-        return [(i, fix_line_from_coverage_file(line), touched_lines[i])
-                for i, line in enumerate(annotated_coverage_file, start=1)
-                if i in touched_lines and i not in ignored_lines
-                if line_counts_as_uncovered(line, has_cover_file)]
+        return [
+            (i, fix_line_from_coverage_file(line), touched_lines[i])
+            for i, line in enumerate(annotated_coverage_file, start=1)
+            if i in touched_lines and i not in ignored_lines
+            if line_counts_as_uncovered(line, has_cover_file)
+        ]
 
 
 def line_content_counts_as_uncovered_manual(content: str) -> bool:
@@ -211,15 +210,13 @@ def determine_ignored_lines(content: str) -> Set[int]:
 def naive_find_end_of_scope(lines: List[str], i: int) -> int:
     # TODO: deal with line continuations, which may be less indented.
     line = lines[i]
-    indent = line[:len(line) - len(line.lstrip())]
-    while i < len(lines) and (not lines[i].strip() or
-                              lines[i].startswith(indent)):
+    indent = line[: len(line) - len(line.lstrip())]
+    while i < len(lines) and (not lines[i].strip() or lines[i].startswith(indent)):
         i += 1
     return i
 
 
-def line_counts_as_uncovered(line: str,
-                             is_from_cover_annotation_file: bool) -> bool:
+def line_counts_as_uncovered(line: str, is_from_cover_annotation_file: bool) -> bool:
     """
     Args:
         line: The line of code (including coverage annotation).
@@ -244,14 +241,13 @@ def line_counts_as_uncovered(line: str,
     # Ignore end-of-line comments.
     # TODO: avoid # in strings, etc.
     if '#' in content:
-        content = content[:content.index('#')].strip()
+        content = content[: content.index('#')].strip()
 
     # Ignored line pattern?
     if any(re.search(pat, content) for pat in IGNORED_LINE_PATTERNS):
         return False
 
-    return (is_from_cover_annotation_file or
-            line_content_counts_as_uncovered_manual(content))
+    return is_from_cover_annotation_file or line_content_counts_as_uncovered_manual(content)
 
 
 def is_applicable_python_file(rel_path: str) -> bool:
@@ -263,8 +259,9 @@ def is_applicable_python_file(rel_path: str) -> bool:
     Returns:
         Whether to include the file.
     """
-    return (rel_path.endswith('.py') and
-            not any(re.search(pat, rel_path) for pat in IGNORED_FILE_PATTERNS))
+    return rel_path.endswith('.py') and not any(
+        re.search(pat, rel_path) for pat in IGNORED_FILE_PATTERNS
+    )
 
 
 def check_for_uncovered_lines(env: env_tools.PreparedEnv) -> int:
@@ -279,31 +276,36 @@ def check_for_uncovered_lines(env: env_tools.PreparedEnv) -> int:
 
         base_path = cast(str, env.destination_directory)
         uncovered_lines = get_incremental_uncovered_lines(
-            os.path.join(base_path, changed_file), env.compare_commit_id,
-            env.actual_commit_id)
+            os.path.join(base_path, changed_file), env.compare_commit_id, env.actual_commit_id
+        )
 
         if uncovered_lines:
             uncovered_count += len(uncovered_lines)
             print(
-                shell_tools.highlight('************* {} ({} uncovered)'.format(
-                    changed_file, len(uncovered_lines)),
-                                      color_code=shell_tools.RED))
+                shell_tools.highlight(
+                    '************* {} ({} uncovered)'.format(changed_file, len(uncovered_lines)),
+                    color_code=shell_tools.RED,
+                )
+            )
         for index, line, reason in uncovered_lines:
-            print('Line {} {} but not covered: {}'.format(
-                shell_tools.highlight(str(index).rjust(4),
-                                      color_code=shell_tools.BOLD), reason,
-                shell_tools.highlight(line, color_code=shell_tools.YELLOW)))
+            print(
+                'Line {} {} but not covered: {}'.format(
+                    shell_tools.highlight(str(index).rjust(4), color_code=shell_tools.BOLD),
+                    reason,
+                    shell_tools.highlight(line, color_code=shell_tools.YELLOW),
+                )
+            )
 
     # Inform of aggregate result.
     print()
     if uncovered_count:
         print(
             shell_tools.highlight(
                 'Found {} uncovered touched lines.'.format(uncovered_count),
-                color_code=shell_tools.RED))
+                color_code=shell_tools.RED,
+            )
+        )
     else:
-        print(
-            shell_tools.highlight('All touched lines covered',
-                                  color_code=shell_tools.GREEN))
+        print(shell_tools.highlight('All touched lines covered', color_code=shell_tools.GREEN))
     print()
     return uncovered_count