jaclang 0.6.1__py3-none-any.whl → 0.6.5__py3-none-any.whl

jaclang/vendor/mypy/suggestions.py

@@ -109,9 +109,7 @@ class SuggestionPlugin(Plugin):
         # (path, line, <arg kinds>, <arg names>, <arg types>)
         self.mystery_hits: list[Callsite] = []
 
-    def get_function_hook(
-        self, fullname: str
-    ) -> Callable[[FunctionContext], Type] | None:
+    def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None:
         if fullname == self.target:
             return self.log
         else:
@@ -170,9 +168,7 @@ class ArgUseFinder(TraverserVisitor):
 
     def __init__(self, func: FuncDef, typemap: dict[Expression, Type]) -> None:
         self.typemap = typemap
-        self.arg_types: dict[SymbolNode, list[Type]] = {
-            arg.variable: [] for arg in func.arguments
-        }
+        self.arg_types: dict[SymbolNode, list[Type]] = {arg.variable: [] for arg in func.arguments}
 
     def visit_call_expr(self, o: CallExpr) -> None:
         if not any(isinstance(e, RefExpr) and e.node in self.arg_types for e in o.args):
@@ -373,9 +369,7 @@ class SuggestionEngine:
                 isinstance(get_proper_type(tp), NoneType) for tp in all_arg_types
             ):
                 arg_types.append(
-                    UnionType.make_union(
-                        [all_arg_types[0], AnyType(TypeOfAny.explicit)]
-                    )
+                    UnionType.make_union([all_arg_types[0], AnyType(TypeOfAny.explicit)])
                 )
             elif all_arg_types:
                 arg_types.extend(generate_type_combinations(all_arg_types))
@@ -411,10 +405,7 @@ class SuggestionEngine:
 
         # Take the first `max_guesses` guesses.
         product = itertools.islice(itertools.product(*options), 0, self.max_guesses)
-        return [
-            refine_callable(base, base.copy_modified(arg_types=list(x)))
-            for x in product
-        ]
+        return [refine_callable(base, base.copy_modified(arg_types=list(x))) for x in product]
 
     def get_callsites(self, func: FuncDef) -> tuple[list[Callsite], list[str]]:
         """Find all call sites of a function."""
@@ -443,9 +434,7 @@ class SuggestionEngine:
             or any_score_callable(t, is_method, ignore_return) >= self.flex_any
         ]
 
-    def find_best(
-        self, func: FuncDef, guesses: list[CallableType]
-    ) -> tuple[CallableType, int]:
+    def find_best(self, func: FuncDef, guesses: list[CallableType]) -> tuple[CallableType, int]:
         """From a list of possible function types, find the best one.
 
         For best, we want the fewest errors, then the best "score" from score_callable.
@@ -453,9 +442,7 @@ class SuggestionEngine:
         if not guesses:
             raise SuggestionFailure("No guesses that match criteria!")
         errors = {guess: self.try_type(func, guess) for guess in guesses}
-        best = min(
-            guesses, key=lambda s: (count_errors(errors[s]), self.score_callable(s))
-        )
+        best = min(guesses, key=lambda s: (count_errors(errors[s]), self.score_callable(s)))
         return best, count_errors(errors[best])
 
     def get_guesses_from_parent(self, node: FuncDef) -> list[CallableType]:
@@ -468,9 +455,7 @@ class SuggestionEngine:
             if pnode and isinstance(pnode.node, (FuncDef, Decorator)):
                 typ = get_proper_type(pnode.node.type)
                 # FIXME: Doesn't work right with generic tyeps
-                if isinstance(typ, CallableType) and len(typ.arg_types) == len(
-                    node.arguments
-                ):
+                if isinstance(typ, CallableType) and len(typ.arg_types) == len(node.arguments):
                     # Return the first thing we find, since it probably doesn't make sense
                     # to grab things further up in the chain if an earlier parent has it.
                     return [typ]
@@ -512,10 +497,7 @@ class SuggestionEngine:
             else:
                 ret_types = [NoneType()]
 
-        guesses = [
-            best.copy_modified(ret_type=refine_type(best.ret_type, t))
-            for t in ret_types
-        ]
+        guesses = [best.copy_modified(ret_type=refine_type(best.ret_type, t)) for t in ret_types]
         guesses = self.filter_options(guesses, is_method, ignore_return=False)
         best, errors = self.find_best(node, guesses)
 
@@ -583,9 +565,7 @@ class SuggestionEngine:
 
         return modname, tail, node
 
-    def find_node_by_module_and_name(
-        self, modname: str, tail: str
-    ) -> SymbolNode | None:
+    def find_node_by_module_and_name(self, modname: str, tail: str) -> SymbolNode | None:
         """Find symbol node by module id and qualified name.
 
         Raise SuggestionFailure if can't find one.
@@ -607,9 +587,7 @@ class SuggestionEngine:
             node: SymbolNode | None = names[component].node
             if not isinstance(node, TypeInfo):
                 raise SuggestionFailure(
-                    "Object {}.{} is not a class".format(
-                        modname, ".".join(components[: i + 1])
-                    )
+                    "Object {}.{} is not a class".format(modname, ".".join(components[: i + 1]))
                 )
             names = node.names
 
@@ -618,15 +596,11 @@ class SuggestionEngine:
         if funcname not in names:
             key = modname + "." + tail
             raise SuggestionFailure(
-                "Unknown {} {}".format(
-                    "method" if len(components) > 1 else "function", key
-                )
+                "Unknown {} {}".format("method" if len(components) > 1 else "function", key)
             )
         return names[funcname].node
 
-    def find_node_by_file_and_line(
-        self, file: str, line: int
-    ) -> tuple[str, SymbolNode]:
+    def find_node_by_file_and_line(self, file: str, line: int) -> tuple[str, SymbolNode]:
         """Find symbol node by path to file and line number.
 
         Find the first function declared *before or on* the line number.
@@ -750,9 +724,7 @@ class SuggestionEngine:
         """Format a callable type as a pyannotate dict"""
         start = int(is_method)
         return {
-            "arg_types": [
-                self.format_type(cur_module, t) for t in typ.arg_types[start:]
-            ],
+            "arg_types": [self.format_type(cur_module, t) for t in typ.arg_types[start:]],
             "return_type": self.format_type(cur_module, typ.ret_type),
         }
 
@@ -787,9 +759,9 @@ class SuggestionEngine:
         return 0
 
     def score_callable(self, t: CallableType) -> int:
-        return sum(
-            self.score_type(x, arg_pos=True) for x in t.arg_types
-        ) + self.score_type(t.ret_type, arg_pos=False)
+        return sum(self.score_type(x, arg_pos=True) for x in t.arg_types) + self.score_type(
+            t.ret_type, arg_pos=False
+        )
 
 
 def any_score_type(ut: Type, arg_pos: bool) -> float:
@@ -863,9 +835,7 @@ class TypeFormatter(TypeStrVisitor):
         # to point to the current module. This helps the annotation tool avoid
         # inserting redundant imports when a type has been reexported.
         if self.module:
-            parts = obj.split(
-                "."
-            )  # need to split the object part if it is a nested class
+            parts = obj.split(".")  # need to split the object part if it is a nested class
             tree = self.graph[self.module].tree
             if tree and parts[0] in tree.names:
                 mod = self.module
@@ -991,9 +961,7 @@ def refine_type(ti: Type, si: Type) -> Type:
         return t if isinstance(s, AnyType) and t.missing_import_name else s
 
     if isinstance(t, Instance) and isinstance(s, Instance) and t.type == s.type:
-        return t.copy_modified(
-            args=[refine_type(ta, sa) for ta, sa in zip(t.args, s.args)]
-        )
+        return t.copy_modified(args=[refine_type(ta, sa) for ta, sa in zip(t.args, s.args)])
 
     if (
         isinstance(t, TupleType)
@@ -1001,9 +969,7 @@ def refine_type(ti: Type, si: Type) -> Type:
         and t.partial_fallback == s.partial_fallback
         and len(t.items) == len(s.items)
     ):
-        return t.copy_modified(
-            items=[refine_type(ta, sa) for ta, sa in zip(t.items, s.items)]
-        )
+        return t.copy_modified(items=[refine_type(ta, sa) for ta, sa in zip(t.items, s.items)])
 
     if isinstance(t, CallableType) and isinstance(s, CallableType):
         return refine_callable(t, s)

jaclang/vendor/mypy/test/data.py

@@ -124,23 +124,17 @@ def parse_test_case(case: DataDrivenTestCase) -> None:
         elif re.match(r"stale[0-9]*$", item.id):
             passnum = 1 if item.id == "stale" else int(item.id[len("stale") :])
             assert passnum > 0
-            modules = (
-                set() if item.arg is None else {t.strip() for t in item.arg.split(",")}
-            )
+            modules = set() if item.arg is None else {t.strip() for t in item.arg.split(",")}
             stale_modules[passnum] = modules
         elif re.match(r"rechecked[0-9]*$", item.id):
             passnum = 1 if item.id == "rechecked" else int(item.id[len("rechecked") :])
             assert passnum > 0
-            modules = (
-                set() if item.arg is None else {t.strip() for t in item.arg.split(",")}
-            )
+            modules = set() if item.arg is None else {t.strip() for t in item.arg.split(",")}
             rechecked_modules[passnum] = modules
         elif re.match(r"targets[0-9]*$", item.id):
             passnum = 1 if item.id == "targets" else int(item.id[len("targets") :])
             assert passnum > 0
-            reprocessed = (
-                [] if item.arg is None else [t.strip() for t in item.arg.split(",")]
-            )
+            reprocessed = [] if item.arg is None else [t.strip() for t in item.arg.split(",")]
             targets[passnum] = reprocessed
         elif item.id == "delete":
             # File/directory to delete during a multi-step test case
@@ -164,9 +158,7 @@ def parse_test_case(case: DataDrivenTestCase) -> None:
                 if arg.startswith("version"):
                     compare_op = arg[7:9]
                     if compare_op not in {">=", "=="}:
-                        _item_fail(
-                            "Only >= and == version checks are currently supported"
-                        )
+                        _item_fail("Only >= and == version checks are currently supported")
                     version_str = arg[9:]
                     try:
                         version = tuple(int(x) for x in version_str.split("."))
@@ -218,9 +210,7 @@ def parse_test_case(case: DataDrivenTestCase) -> None:
             and passnum in rechecked_modules
             and not stale_modules[passnum].issubset(rechecked_modules[passnum])
         ):
-            _case_fail(
-                f"Stale modules after pass {passnum} must be a subset of rechecked modules"
-            )
+            _case_fail(f"Stale modules after pass {passnum} must be a subset of rechecked modules")
 
     output_inline_start = len(output)
     input = first_item.data
@@ -231,9 +221,7 @@ def parse_test_case(case: DataDrivenTestCase) -> None:
     seen_files = set()
     for file, _ in files:
         if file in seen_files:
-            _case_fail(
-                f"Duplicated filename {file}. Did you include it multiple times?"
-            )
+            _case_fail(f"Duplicated filename {file}. Did you include it multiple times?")
 
         seen_files.add(file)
 
@@ -281,9 +269,7 @@ class DataDrivenTestCase(pytest.Item):
 
     # Extra attributes used by some tests.
     last_line: int
-    output_files: list[
-        tuple[str, str | Pattern[str]]
-    ]  # Path and contents for output files
+    output_files: list[tuple[str, str | Pattern[str]]]  # Path and contents for output files
     deleted_paths: dict[int, set[str]]  # Mapping run number -> paths
     triggered: list[str]  # Active triggers (one line per incremental step)
 
@@ -405,10 +391,7 @@ class DataDrivenTestCase(pytest.Item):
             # In particular, uncaught exceptions during semantic analysis or type checking
             # call exit() and they already print out a stack trace.
             excrepr = excinfo.exconly()
-        elif (
-            isinstance(excinfo.value, pytest.fail.Exception)
-            and not excinfo.value.pytrace
-        ):
+        elif isinstance(excinfo.value, pytest.fail.Exception) and not excinfo.value.pytrace:
             excrepr = excinfo.exconly()
         else:
             excinfo.traceback = self.parent._traceback_filter(excinfo)
@@ -552,8 +535,7 @@ def expand_errors(input: list[str], output: list[str], fnam: str) -> None:
         # The first in the split things isn't a comment
         for possible_err_comment in input[i].split(" # ")[1:]:
             m = re.search(
-                r"^([ENW]):((?P<col>\d+):)? (?P<message>.*)$",
-                possible_err_comment.strip(),
+                r"^([ENW]):((?P<col>\d+):)? (?P<message>.*)$", possible_err_comment.strip()
             )
             if m:
                 if m.group(1) == "E":
@@ -621,9 +603,7 @@ def pytest_addoption(parser: Any) -> None:
         help="Copy the temp directories from failing tests to a target directory",
     )
     group.addoption(
-        "--mypy-verbose",
-        action="count",
-        help="Set the verbose flag when creating mypy Options",
+        "--mypy-verbose", action="count", help="Set the verbose flag when creating mypy Options"
     )
     group.addoption(
         "--mypyc-showc",
@@ -641,10 +621,7 @@ def pytest_addoption(parser: Any) -> None:
 
 
 def pytest_configure(config: pytest.Config) -> None:
-    if (
-        config.getoption("--update-data")
-        and config.getoption("--numprocesses", default=1) > 1
-    ):
+    if config.getoption("--update-data") and config.getoption("--numprocesses", default=1) > 1:
         raise pytest.UsageError(
             "--update-data incompatible with parallelized tests; re-run with -n 1"
         )
@@ -663,9 +640,7 @@ def pytest_pycollect_makeitem(collector: Any, name: str, obj: object) -> Any | N
             # Non-None result means this obj is a test case.
             # The collect method of the returned DataSuiteCollector instance will be called later,
             # with self.obj being obj.
-            return DataSuiteCollector.from_parent(  # type: ignore[no-untyped-call]
-                parent=collector, name=name
-            )
+            return DataSuiteCollector.from_parent(parent=collector, name=name)
     return None
 
 
@@ -690,9 +665,7 @@ def split_test_cases(
     """
     with open(file, encoding="utf-8") as f:
         data = f.read()
-    cases = re.split(
-        r"^\[case ([^]+)]+)\][ \t]*$\n", data, flags=re.DOTALL | re.MULTILINE
-    )
+    cases = re.split(r"^\[case ([^]+)]+)\][ \t]*$\n", data, flags=re.DOTALL | re.MULTILINE)
     cases_iter = iter(cases)
     line_no = next(cases_iter).count("\n") + 1
     test_names = set()

jaclang/vendor/mypy/test/helpers.py

@@ -24,12 +24,7 @@ from mypy import defaults
 from mypy.main import process_options
 from mypy.options import Options
 from mypy.test.config import test_data_prefix, test_temp_dir
-from mypy.test.data import (
-    DataDrivenTestCase,
-    DeleteFile,
-    UpdateFile,
-    fix_cobertura_filename,
-)
+from mypy.test.data import DataDrivenTestCase, DeleteFile, UpdateFile, fix_cobertura_filename
 
 skip = pytest.mark.skip
 
@@ -42,13 +37,11 @@ def run_mypy(args: list[str]) -> None:
     __tracebackhide__ = True
     # We must enable site packages even though they could cause problems,
     # since stubs for typing_extensions live there.
-    outval, errval, status = api.run(
-        args + ["--show-traceback", "--no-silence-site-packages"]
-    )
+    outval, errval, status = api.run(args + ["--show-traceback", "--no-silence-site-packages"])
     if status != 0:
         sys.stdout.write(outval)
         sys.stderr.write(errval)
-        pytest.fail(msg="Sample check failed", pytrace=False)
+        pytest.fail(reason="Sample check failed", pytrace=False)
 
 
 def diff_ranges(
@@ -111,9 +104,7 @@ def render_diff_range(
             output.write("\n")
 
 
-def assert_string_arrays_equal(
-    expected: list[str], actual: list[str], msg: str
-) -> None:
+def assert_string_arrays_equal(expected: list[str], actual: list[str], msg: str) -> None:
     """Assert that two string arrays are equal.
 
     Display any differences in a human-readable form.
@@ -148,30 +139,26 @@ def assert_string_arrays_equal(
         pytest.fail(msg, pytrace=False)
 
 
-def assert_module_equivalence(
-    name: str, expected: Iterable[str], actual: Iterable[str]
-) -> None:
+def assert_module_equivalence(name: str, expected: Iterable[str], actual: Iterable[str]) -> None:
     expected_normalized = sorted(expected)
     actual_normalized = sorted(set(actual).difference({"__main__"}))
     assert_string_arrays_equal(
         expected_normalized,
         actual_normalized,
-        (
-            'Actual modules ({}) do not match expected modules ({}) for "[{} ...]"'
-        ).format(", ".join(actual_normalized), ", ".join(expected_normalized), name),
+        ('Actual modules ({}) do not match expected modules ({}) for "[{} ...]"').format(
+            ", ".join(actual_normalized), ", ".join(expected_normalized), name
+        ),
     )
 
 
-def assert_target_equivalence(
-    name: str, expected: list[str], actual: list[str]
-) -> None:
+def assert_target_equivalence(name: str, expected: list[str], actual: list[str]) -> None:
     """Compare actual and expected targets (order sensitive)."""
     assert_string_arrays_equal(
         expected,
         actual,
-        (
-            'Actual targets ({}) do not match expected targets ({}) for "[{} ...]"'
-        ).format(", ".join(actual), ", ".join(expected), name),
+        ('Actual targets ({}) do not match expected targets ({}) for "[{} ...]"').format(
+            ", ".join(actual), ", ".join(expected), name
+        ),
     )
 
 
@@ -341,9 +328,7 @@ def typename(t: type) -> str:
 def assert_type(typ: type, value: object) -> None:
     __tracebackhide__ = True
     if type(value) != typ:
-        raise AssertionError(
-            f"Invalid type {typename(type(value))}, expected {typename(typ)}"
-        )
+        raise AssertionError(f"Invalid type {typename(type(value))}, expected {typename(typ)}")
 
 
 def parse_options(
@@ -353,23 +338,17 @@ def parse_options(
     options = Options()
     flags = re.search("# flags: (.*)$", program_text, flags=re.MULTILINE)
     if incremental_step > 1:
-        flags2 = re.search(
-            f"# flags{incremental_step}: (.*)$", program_text, flags=re.MULTILINE
-        )
+        flags2 = re.search(f"# flags{incremental_step}: (.*)$", program_text, flags=re.MULTILINE)
         if flags2:
             flags = flags2
 
     if flags:
         flag_list = flags.group(1).split()
-        flag_list.append(
-            "--no-site-packages"
-        )  # the tests shouldn't need an installed Python
+        flag_list.append("--no-site-packages")  # the tests shouldn't need an installed Python
         targets, options = process_options(flag_list, require_targets=False)
         if targets:
             # TODO: support specifying targets via the flags pragma
-            raise RuntimeError(
-                "Specifying targets via the flags pragma is not supported."
-            )
+            raise RuntimeError("Specifying targets via the flags pragma is not supported.")
         if "--show-error-codes" not in flag_list:
             options.hide_error_codes = True
     else:
@@ -464,9 +443,7 @@ def check_test_output_files(
         # specific things if requested.
         if testcase.normalize_output:
             if testcase.suite.native_sep and os.path.sep == "\\":
-                normalized_output = [
-                    fix_cobertura_filename(line) for line in normalized_output
-                ]
+                normalized_output = [fix_cobertura_filename(line) for line in normalized_output]
             normalized_output = normalize_error_messages(normalized_output)
         assert_string_arrays_equal(
             expected_content.splitlines(),
@@ -486,9 +463,7 @@ def normalize_file_output(content: list[str], current_abs_path: str) -> list[str
     # We generate a new mypy.version when building mypy wheels that
     # lacks base_version, so handle that case.
     base_version = getattr(mypy.version, "base_version", version)
-    result = [
-        re.sub(r"\b" + re.escape(base_version) + r"\b", "$VERSION", x) for x in result
-    ]
+    result = [re.sub(r"\b" + re.escape(base_version) + r"\b", "$VERSION", x) for x in result]
     result = [timestamp_regex.sub("$TIMESTAMP", x) for x in result]
     return result
 

jaclang/vendor/mypy/test/meta/_pytest.py

@@ -45,22 +45,11 @@ def run_pytest_data_suite(
         p.write_text(data_suite)
 
         test_nodeid = f"{pytest_node_prefix}::{p.name}"
-        extra_args = [
-            sys.executable,
-            "-m",
-            "pytest",
-            "-n",
-            "0",
-            "-s",
-            *extra_args,
-            test_nodeid,
-        ]
+        extra_args = [sys.executable, "-m", "pytest", "-n", "0", "-s", *extra_args, test_nodeid]
         cmd = shlex.join(extra_args)
         for i in range(max_attempts - 1, -1, -1):
             print(f">> {cmd}")
-            proc = subprocess.run(
-                extra_args, capture_output=True, check=False, cwd=p_root
-            )
+            proc = subprocess.run(extra_args, capture_output=True, check=False, cwd=p_root)
             if proc.returncode == 0:
                 break
             prefix = "NESTED PYTEST STDOUT"

jaclang/vendor/mypy/test/meta/test_parse_data.py

@@ -39,7 +39,9 @@ class ParseTestDataSuite(Suite):
 
         # Assert
         expected_lineno = result.input.splitlines().index("[unknownsection]") + 1
-        expected = f".test:{expected_lineno}: Invalid section header [unknownsection] in case 'abc'"
+        expected = (
+            f".test:{expected_lineno}: Invalid section header [unknownsection] in case 'abc'"
+        )
         assert expected in result.stdout
 
     def test_bad_ge_version_check(self) -> None:
@@ -54,10 +56,7 @@ class ParseTestDataSuite(Suite):
         )
 
         # Assert
-        assert (
-            "version>=3.8 always true since minimum runtime version is (3, 8)"
-            in actual.stdout
-        )
+        assert "version>=3.8 always true since minimum runtime version is (3, 8)" in actual.stdout
 
     def test_bad_eq_version_check(self) -> None:
         # Act
@@ -71,7 +70,4 @@ class ParseTestDataSuite(Suite):
         )
 
         # Assert
-        assert (
-            "version==3.7 always false since minimum runtime version is (3, 8)"
-            in actual.stdout
-        )
+        assert "version==3.7 always false since minimum runtime version is (3, 8)" in actual.stdout

jaclang/vendor/mypy/test/meta/test_update_data.py

@@ -13,9 +13,7 @@ def _run_pytest_update_data(data_suite: str) -> PytestResult:
     Runs a suite of data test cases through 'pytest --update-data' until either tests pass
     or until a maximum number of attempts (needed for incremental tests).
     """
-    return run_pytest_data_suite(
-        data_suite, extra_args=["--update-data"], max_attempts=3
-    )
+    return run_pytest_data_suite(data_suite, extra_args=["--update-data"], max_attempts=3)
 
 
 class UpdateDataSuite(Suite):

jaclang/vendor/mypy/test/test_find_sources.py

@@ -28,9 +28,7 @@ class FakeFSCache(FileSystemCache):
     def listdir(self, dir: str) -> list[str]:
         if not dir.endswith(os.sep):
             dir += os.sep
-        return list(
-            {f[len(dir) :].split(os.sep)[0] for f in self.files if f.startswith(dir)}
-        )
+        return list({f[len(dir) :].split(os.sep)[0] for f in self.files if f.startswith(dir)})
 
     def init_under_package_root(self, file: str) -> bool:
         return False
@@ -42,9 +40,7 @@ def normalise_path(path: str) -> str:
     return path
 
 
-def normalise_build_source_list(
-    sources: list[BuildSource],
-) -> list[tuple[str, str | None]]:
+def normalise_build_source_list(sources: list[BuildSource]) -> list[tuple[str, str | None]]:
     return sorted(
         (s.module, (normalise_path(s.base_dir) if s.base_dir is not None else None))
         for s in sources
@@ -93,17 +89,14 @@ class SourceFinderSuite(unittest.TestCase):
         finder = SourceFinder(FakeFSCache({"/a/setup.py", "/a/__init__.py"}), options)
         assert crawl(finder, "/a/setup.py") == ("a.setup", "/")
 
-        finder = SourceFinder(
-            FakeFSCache({"/a/invalid-name/setup.py", "/a/__init__.py"}), options
-        )
+        finder = SourceFinder(FakeFSCache({"/a/invalid-name/setup.py", "/a/__init__.py"}), options)
         assert crawl(finder, "/a/invalid-name/setup.py") == ("setup", "/a/invalid-name")
 
         finder = SourceFinder(FakeFSCache({"/a/b/setup.py", "/a/__init__.py"}), options)
         assert crawl(finder, "/a/b/setup.py") == ("setup", "/a/b")
 
         finder = SourceFinder(
-            FakeFSCache({"/a/b/c/setup.py", "/a/__init__.py", "/a/b/c/__init__.py"}),
-            options,
+            FakeFSCache({"/a/b/c/setup.py", "/a/__init__.py", "/a/b/c/__init__.py"}), options
         )
         assert crawl(finder, "/a/b/c/setup.py") == ("c.setup", "/a/b")
 
@@ -123,17 +116,14 @@ class SourceFinderSuite(unittest.TestCase):
         finder = SourceFinder(FakeFSCache({"/a/setup.py", "/a/__init__.py"}), options)
         assert crawl(finder, "/a/setup.py") == ("a.setup", "/")
 
-        finder = SourceFinder(
-            FakeFSCache({"/a/invalid-name/setup.py", "/a/__init__.py"}), options
-        )
+        finder = SourceFinder(FakeFSCache({"/a/invalid-name/setup.py", "/a/__init__.py"}), options)
         assert crawl(finder, "/a/invalid-name/setup.py") == ("setup", "/a/invalid-name")
 
         finder = SourceFinder(FakeFSCache({"/a/b/setup.py", "/a/__init__.py"}), options)
         assert crawl(finder, "/a/b/setup.py") == ("a.b.setup", "/")
 
         finder = SourceFinder(
-            FakeFSCache({"/a/b/c/setup.py", "/a/__init__.py", "/a/b/c/__init__.py"}),
-            options,
+            FakeFSCache({"/a/b/c/setup.py", "/a/__init__.py", "/a/b/c/__init__.py"}), options
         )
         assert crawl(finder, "/a/b/c/setup.py") == ("a.b.c.setup", "/")
 
@@ -154,17 +144,14 @@ class SourceFinderSuite(unittest.TestCase):
         finder = SourceFinder(FakeFSCache({"/a/setup.py", "/a/__init__.py"}), options)
         assert crawl(finder, "/a/setup.py") == ("a.setup", "/")
 
-        finder = SourceFinder(
-            FakeFSCache({"/a/invalid-name/setup.py", "/a/__init__.py"}), options
-        )
+        finder = SourceFinder(FakeFSCache({"/a/invalid-name/setup.py", "/a/__init__.py"}), options)
         assert crawl(finder, "/a/invalid-name/setup.py") == ("setup", "/a/invalid-name")
 
         finder = SourceFinder(FakeFSCache({"/a/b/setup.py", "/a/__init__.py"}), options)
         assert crawl(finder, "/a/b/setup.py") == ("a.b.setup", "/")
 
         finder = SourceFinder(
-            FakeFSCache({"/a/b/c/setup.py", "/a/__init__.py", "/a/b/c/__init__.py"}),
-            options,
+            FakeFSCache({"/a/b/c/setup.py", "/a/__init__.py", "/a/b/c/__init__.py"}), options
         )
         assert crawl(finder, "/a/b/c/setup.py") == ("a.b.c.setup", "/")
 
@@ -175,8 +162,7 @@ class SourceFinderSuite(unittest.TestCase):
         assert crawl(finder, "/a/b/c/setup.py") == ("c.setup", "/a/b")
 
         finder = SourceFinder(
-            FakeFSCache({"/a/b/c/setup.py", "/a/__init__.py", "/a/b/c/__init__.py"}),
-            options,
+            FakeFSCache({"/a/b/c/setup.py", "/a/__init__.py", "/a/b/c/__init__.py"}), options
         )
         assert crawl(finder, "/a/b/c/setup.py") == ("c.setup", "/a/b")
 
@@ -288,9 +274,9 @@ class SourceFinderSuite(unittest.TestCase):
             assert find_sources([f"/dir/venv/{excluded_dir}"], options, fscache) == [
                 ("b", f"/dir/venv/{excluded_dir}")
             ]
-            assert find_sources(
-                [f"/dir/venv/{excluded_dir}/b.py"], options, fscache
-            ) == [("b", f"/dir/venv/{excluded_dir}")]
+            assert find_sources([f"/dir/venv/{excluded_dir}/b.py"], options, fscache) == [
+                ("b", f"/dir/venv/{excluded_dir}")
+            ]
 
         files = {
             "/pkg/a1/b/c/d/e.py",
@@ -308,12 +294,8 @@ class SourceFinderSuite(unittest.TestCase):
             ("a2.b.c.d.e", "/pkg"),
             ("e", "/pkg/a1/b/c/d"),
         ]
-        assert find_sources(["/pkg/a1/b/f.py"], options, fscache) == [
-            ("f", "/pkg/a1/b")
-        ]
-        assert find_sources(["/pkg/a2/b/f.py"], options, fscache) == [
-            ("a2.b.f", "/pkg")
-        ]
+        assert find_sources(["/pkg/a1/b/f.py"], options, fscache) == [("f", "/pkg/a1/b")]
+        assert find_sources(["/pkg/a2/b/f.py"], options, fscache) == [("a2.b.f", "/pkg")]
 
         # directory name
         options.exclude = ["/a1/"]