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

jaclang/vendor/mypy/test/test_ref_info.py

@@ -26,16 +26,12 @@ class RefInfoSuite(DataSuite):
 
         src = "\n".join(testcase.input)
         result = build.build(
-            sources=[BuildSource("main", None, src)],
-            options=options,
-            alt_lib_path=test_temp_dir,
+            sources=[BuildSource("main", None, src)], options=options, alt_lib_path=test_temp_dir
         )
         assert not result.errors
 
         major, minor = sys.version_info[:2]
-        ref_path = os.path.join(
-            options.cache_dir, f"{major}.{minor}", "__main__.refs.json"
-        )
+        ref_path = os.path.join(options.cache_dir, f"{major}.{minor}", "__main__.refs.json")
 
         with open(ref_path) as refs_file:
             data = json.load(refs_file)
@@ -45,7 +41,5 @@ class RefInfoSuite(DataSuite):
             a.append(f"{item['line']}:{item['column']}:{item['target']}")
 
         assert_string_arrays_equal(
-            testcase.output,
-            a,
-            f"Invalid output ({testcase.file}, line {testcase.line})",
+            testcase.output, a, f"Invalid output ({testcase.file}, line {testcase.line})"
         )

jaclang/vendor/mypy/test/testargs.py

@@ -50,10 +50,7 @@ class ArgSuite(Suite):
         assert options.python_executable == sys.executable
 
         # test that --no-site-packages will disable executable inference
-        matching_version = base + [
-            f"--python-version={sys_ver_str}",
-            "--no-site-packages",
-        ]
+        matching_version = base + [f"--python-version={sys_ver_str}", "--no-site-packages"]
         _, options = process_options(matching_version)
         assert options.python_version == sys.version_info[:2]
         assert options.python_executable is None

jaclang/vendor/mypy/test/testcheck.py

@@ -11,12 +11,7 @@ from mypy.build import Graph
 from mypy.errors import CompileError
 from mypy.modulefinder import BuildSource, FindModuleCache, SearchPaths
 from mypy.test.config import test_data_prefix, test_temp_dir
-from mypy.test.data import (
-    DataDrivenTestCase,
-    DataSuite,
-    FileOperation,
-    module_from_path,
-)
+from mypy.test.data import DataDrivenTestCase, DataSuite, FileOperation, module_from_path
 from mypy.test.helpers import (
     assert_module_equivalence,
     assert_string_arrays_equal,
@@ -89,9 +84,7 @@ class TypeCheckSuite(DataSuite):
         else:
             self.run_case_once(testcase)
 
-    def _sort_output_if_needed(
-        self, testcase: DataDrivenTestCase, a: list[str]
-    ) -> None:
+    def _sort_output_if_needed(self, testcase: DataDrivenTestCase, a: list[str]) -> None:
         idx = testcase.output_inline_start
         if not testcase.files or idx == len(testcase.output):
             return
@@ -99,9 +92,7 @@ class TypeCheckSuite(DataSuite):
         def _filename(_msg: str) -> str:
             return _msg.partition(":")[0]
 
-        file_weights = {
-            file: idx for idx, file in enumerate(_filename(msg) for msg in a)
-        }
+        file_weights = {file: idx for idx, file in enumerate(_filename(msg) for msg in a)}
         testcase.output[idx:] = sorted(
             testcase.output[idx:], key=lambda msg: file_weights.get(_filename(msg), -1)
         )
@@ -163,11 +154,7 @@ class TypeCheckSuite(DataSuite):
         for module_name, program_path, program_text in module_data:
             # Always set to none so we're forced to reread the module in incremental mode
             sources.append(
-                BuildSource(
-                    program_path,
-                    module_name,
-                    None if incremental_step else program_text,
-                )
+                BuildSource(program_path, module_name, None if incremental_step else program_text)
             )
 
         plugin_dir = os.path.join(test_data_prefix, "plugins")
@@ -175,9 +162,7 @@ class TypeCheckSuite(DataSuite):
 
         res = None
         try:
-            res = build.build(
-                sources=sources, options=options, alt_lib_path=test_temp_dir
-            )
+            res = build.build(sources=sources, options=options, alt_lib_path=test_temp_dir)
             a = res.errors
         except CompileError as e:
             a = e.messages
@@ -191,9 +176,7 @@ class TypeCheckSuite(DataSuite):
         # Make sure error messages match
         if incremental_step < 2:
             if incremental_step == 1:
-                msg = (
-                    "Unexpected type checker output in incremental, run 1 ({}, line {})"
-                )
+                msg = "Unexpected type checker output in incremental, run 1 ({}, line {})"
             else:
                 assert incremental_step == 0
                 msg = "Unexpected type checker output ({}, line {})"
@@ -228,18 +211,12 @@ class TypeCheckSuite(DataSuite):
                 assert_target_equivalence(name, expected, actual)
             if incremental_step > 1:
                 suffix = "" if incremental_step == 2 else str(incremental_step - 1)
-                expected_rechecked = testcase.expected_rechecked_modules.get(
-                    incremental_step - 1
-                )
+                expected_rechecked = testcase.expected_rechecked_modules.get(incremental_step - 1)
                 if expected_rechecked is not None:
                     assert_module_equivalence(
-                        "rechecked" + suffix,
-                        expected_rechecked,
-                        res.manager.rechecked_modules,
+                        "rechecked" + suffix, expected_rechecked, res.manager.rechecked_modules
                     )
-                expected_stale = testcase.expected_stale_modules.get(
-                    incremental_step - 1
-                )
+                expected_stale = testcase.expected_stale_modules.get(incremental_step - 1)
                 if expected_stale is not None:
                     assert_module_equivalence(
                         "stale" + suffix, expected_stale, res.manager.stale_modules
@@ -259,9 +236,7 @@ class TypeCheckSuite(DataSuite):
         # for those that had an error in themselves or one of their
         # dependencies.
         error_paths = self.find_error_message_paths(a)
-        busted_paths = {
-            m.path for id, m in manager.modules.items() if graph[id].transitive_error
-        }
+        busted_paths = {m.path for id, m in manager.modules.items() if graph[id].transitive_error}
         modules = self.find_module_files(manager)
         modules.update({module_name: path for module_name, path, text in module_data})
         missing_paths = self.find_missing_cache_files(modules, manager)
@@ -269,13 +244,9 @@ class TypeCheckSuite(DataSuite):
         # but this runs into trouble because while some 'notes' are
         # really errors that cause an error to be marked, many are
         # just notes attached to other errors.
-        assert (
-            error_paths or not busted_paths
-        ), "Some modules reported error despite no errors"
+        assert error_paths or not busted_paths, "Some modules reported error despite no errors"
         if not missing_paths == busted_paths:
-            raise AssertionError(
-                f"cache data discrepancy {missing_paths} != {busted_paths}"
-            )
+            raise AssertionError(f"cache data discrepancy {missing_paths} != {busted_paths}")
         assert os.path.isfile(os.path.join(manager.options.cache_dir, ".gitignore"))
         cachedir_tag = os.path.join(manager.options.cache_dir, "CACHEDIR.TAG")
         assert os.path.isfile(cachedir_tag)
@@ -322,9 +293,7 @@ class TypeCheckSuite(DataSuite):
 
         Return a list of tuples (module name, file name, program text).
         """
-        m = re.search(
-            "# cmd: mypy -m ([a-zA-Z0-9_. ]+)$", program_text, flags=re.MULTILINE
-        )
+        m = re.search("# cmd: mypy -m ([a-zA-Z0-9_. ]+)$", program_text, flags=re.MULTILINE)
         if incremental_step > 1:
             alt_regex = f"# cmd{incremental_step}: mypy -m ([a-zA-Z0-9_. ]+)$"
             alt_m = re.search(alt_regex, program_text, flags=re.MULTILINE)
@@ -344,9 +313,7 @@ class TypeCheckSuite(DataSuite):
             cache = FindModuleCache(search_paths, fscache=None, options=None)
             for module_name in module_names.split(" "):
                 path = cache.find_module(module_name)
-                assert isinstance(
-                    path, str
-                ), f"Can't find ad hoc case file: {module_name}"
+                assert isinstance(path, str), f"Can't find ad hoc case file: {module_name}"
                 with open(path, encoding="utf8") as f:
                     program_text = f.read()
                 out.append((module_name, path, program_text))

jaclang/vendor/mypy/test/testcmdline.py

@@ -30,12 +30,7 @@ import pytest
 python3_path = sys.executable
 
 # Files containing test case descriptions.
-cmdline_files = [
-    "cmdline.test",
-    "cmdline.pyproject.test",
-    "reports.test",
-    "envvars.test",
-]
+cmdline_files = ["cmdline.test", "cmdline.pyproject.test", "reports.test", "envvars.test"]
 
 
 class PythonCmdlineSuite(DataSuite):
@@ -104,11 +99,7 @@ def test_python_cmdline(testcase: DataDrivenTestCase, step: int) -> None:
         if err or result:
             raise AssertionError(
                 "Expected zero status and empty stderr%s, got %d and\n%s"
-                % (
-                    " on step %d" % step if testcase.output2 else "",
-                    result,
-                    "\n".join(err + out),
-                )
+                % (" on step %d" % step if testcase.output2 else "", result, "\n".join(err + out))
             )
         check_test_output_files(testcase, step)
     else:
@@ -124,9 +115,7 @@ def test_python_cmdline(testcase: DataDrivenTestCase, step: int) -> None:
             expected_out,
             out,
             "Invalid output ({}, line {}){}".format(
-                testcase.file,
-                testcase.line,
-                " on step %d" % step if testcase.output2 else "",
+                testcase.file, testcase.line, " on step %d" % step if testcase.output2 else ""
             ),
         )
 

jaclang/vendor/mypy/test/testconstraints.py

@@ -23,35 +23,23 @@ class ConstraintsSuite(Suite):
     def test_basic_type_var_tuple_subtype(self) -> None:
         fx = self.fx
         assert infer_constraints(
-            Instance(fx.gvi, [UnpackType(fx.ts)]),
-            Instance(fx.gvi, [fx.a, fx.b]),
-            SUBTYPE_OF,
+            Instance(fx.gvi, [UnpackType(fx.ts)]), Instance(fx.gvi, [fx.a, fx.b]), SUBTYPE_OF
         ) == [
-            Constraint(
-                type_var=fx.ts,
-                op=SUBTYPE_OF,
-                target=TupleType([fx.a, fx.b], fx.std_tuple),
-            )
+            Constraint(type_var=fx.ts, op=SUBTYPE_OF, target=TupleType([fx.a, fx.b], fx.std_tuple))
         ]
 
     def test_basic_type_var_tuple(self) -> None:
         fx = self.fx
         assert set(
             infer_constraints(
-                Instance(fx.gvi, [UnpackType(fx.ts)]),
-                Instance(fx.gvi, [fx.a, fx.b]),
-                SUPERTYPE_OF,
+                Instance(fx.gvi, [UnpackType(fx.ts)]), Instance(fx.gvi, [fx.a, fx.b]), SUPERTYPE_OF
             )
         ) == {
             Constraint(
-                type_var=fx.ts,
-                op=SUPERTYPE_OF,
-                target=TupleType([fx.a, fx.b], fx.std_tuple),
+                type_var=fx.ts, op=SUPERTYPE_OF, target=TupleType([fx.a, fx.b], fx.std_tuple)
             ),
             Constraint(
-                type_var=fx.ts,
-                op=SUBTYPE_OF,
-                target=TupleType([fx.a, fx.b], fx.std_tuple),
+                type_var=fx.ts, op=SUBTYPE_OF, target=TupleType([fx.a, fx.b], fx.std_tuple)
             ),
         }
 
@@ -66,14 +54,10 @@ class ConstraintsSuite(Suite):
         ) == {
             Constraint(type_var=fx.t, op=SUPERTYPE_OF, target=fx.a),
             Constraint(
-                type_var=fx.ts,
-                op=SUPERTYPE_OF,
-                target=TupleType([fx.b, fx.c], fx.std_tuple),
+                type_var=fx.ts, op=SUPERTYPE_OF, target=TupleType([fx.b, fx.c], fx.std_tuple)
             ),
             Constraint(
-                type_var=fx.ts,
-                op=SUBTYPE_OF,
-                target=TupleType([fx.b, fx.c], fx.std_tuple),
+                type_var=fx.ts, op=SUBTYPE_OF, target=TupleType([fx.b, fx.c], fx.std_tuple)
             ),
             Constraint(type_var=fx.s, op=SUPERTYPE_OF, target=fx.d),
         }
@@ -97,9 +81,7 @@ class ConstraintsSuite(Suite):
         fx = self.fx
         assert set(
             infer_constraints(
-                Instance(
-                    fx.gv2i, [fx.t, UnpackType(Instance(fx.std_tuplei, [fx.s])), fx.u]
-                ),
+                Instance(fx.gv2i, [fx.t, UnpackType(Instance(fx.std_tuplei, [fx.s])), fx.u]),
                 Instance(fx.gv2i, [fx.a, fx.b, fx.c, fx.d]),
                 SUPERTYPE_OF,
             )

jaclang/vendor/mypy/test/testdaemon.py

@@ -87,12 +87,7 @@ def run_cmd(input: str) -> tuple[int, str]:
     env["PYTHONPATH"] = PREFIX
     try:
         output = subprocess.check_output(
-            input,
-            shell=True,
-            stderr=subprocess.STDOUT,
-            text=True,
-            cwd=test_temp_dir,
-            env=env,
+            input, shell=True, stderr=subprocess.STDOUT, text=True, cwd=test_temp_dir, env=env
         )
         return 0, output
     except subprocess.CalledProcessError as err:
@@ -125,9 +120,7 @@ class DaemonUtilitySuite(unittest.TestCase):
             )
             fscache = FileSystemCache()
             res = filter_out_missing_top_level_packages(
-                {"a", "b", "c", "d", "e", "f", "g", "long_name", "ff", "missing"},
-                search,
-                fscache,
+                {"a", "b", "c", "d", "e", "f", "g", "long_name", "ff", "missing"}, search, fscache
             )
             assert res == {"a", "b", "c", "d", "f", "long_name"}
 

jaclang/vendor/mypy/test/testdeps.py

@@ -38,18 +38,12 @@ class GetDependenciesSuite(DataSuite):
         a = messages
         if files is None or type_map is None:
             if not a:
-                a = [
-                    "Unknown compile error (likely syntax error in test case or fixture)"
-                ]
+                a = ["Unknown compile error (likely syntax error in test case or fixture)"]
         else:
             deps: defaultdict[str, set[str]] = defaultdict(set)
             for module, file in files.items():
-                if (module in dumped_modules or dump_all) and (
-                    module in testcase.test_modules
-                ):
-                    new_deps = get_dependencies(
-                        file, type_map, options.python_version, options
-                    )
+                if (module in dumped_modules or dump_all) and (module in testcase.test_modules):
+                    new_deps = get_dependencies(file, type_map, options.python_version, options)
                     for source in new_deps:
                         deps[source].update(new_deps[source])
 
@@ -65,9 +59,7 @@ class GetDependenciesSuite(DataSuite):
                 a.append(line)
 
         assert_string_arrays_equal(
-            testcase.output,
-            a,
-            f"Invalid output ({testcase.file}, line {testcase.line})",
+            testcase.output, a, f"Invalid output ({testcase.file}, line {testcase.line})"
         )
 
     def build(

jaclang/vendor/mypy/test/testdiff.py

@@ -46,14 +46,10 @@ class ASTDiffSuite(DataSuite):
             a.append(trigger)
 
         assert_string_arrays_equal(
-            testcase.output,
-            a,
-            f"Invalid output ({testcase.file}, line {testcase.line})",
+            testcase.output, a, f"Invalid output ({testcase.file}, line {testcase.line})"
         )
 
-    def build(
-        self, source: str, options: Options
-    ) -> tuple[list[str], dict[str, MypyFile] | None]:
+    def build(self, source: str, options: Options) -> tuple[list[str], dict[str, MypyFile] | None]:
         options.use_builtins_fixtures = True
         options.show_traceback = True
         options.cache_dir = os.devnull

jaclang/vendor/mypy/test/testerrorstream.py

@@ -42,7 +42,5 @@ def test_error_stream(testcase: DataDrivenTestCase) -> None:
         assert e.messages == []
 
     assert_string_arrays_equal(
-        testcase.output,
-        logged_messages,
-        f"Invalid output ({testcase.file}, line {testcase.line})",
+        testcase.output, logged_messages, f"Invalid output ({testcase.file}, line {testcase.line})"
     )

jaclang/vendor/mypy/test/testfinegrained.py

@@ -128,9 +128,7 @@ class FineGrainedSuite(DataSuite):
         a = [line.replace("\\", "/") for line in a]
 
         assert_string_arrays_equal(
-            testcase.output,
-            a,
-            f"Invalid output ({testcase.file}, line {testcase.line})",
+            testcase.output, a, f"Invalid output ({testcase.file}, line {testcase.line})"
         )
 
         if testcase.triggered:
@@ -140,9 +138,7 @@ class FineGrainedSuite(DataSuite):
                 f"Invalid active triggers ({testcase.file}, line {testcase.line})",
             )
 
-    def get_options(
-        self, source: str, testcase: DataDrivenTestCase, build_cache: bool
-    ) -> Options:
+    def get_options(self, source: str, testcase: DataDrivenTestCase, build_cache: bool) -> Options:
         # This handles things like '# flags: --foo'.
         options = parse_options(source, testcase, incremental_step=1)
         options.incremental = True
@@ -168,9 +164,7 @@ class FineGrainedSuite(DataSuite):
         return options
 
     def run_check(self, server: Server, sources: list[BuildSource]) -> list[str]:
-        response = server.check(
-            sources, export_types=False, is_tty=False, terminal_width=-1
-        )
+        response = server.check(sources, export_types=False, is_tty=False, terminal_width=-1)
         out = response["out"] or response["err"]
         assert isinstance(out, str)
         return out.splitlines()
@@ -241,9 +235,7 @@ class FineGrainedSuite(DataSuite):
 
         expected_rechecked = testcase.expected_rechecked_modules.get(step - 1)
         if expected_rechecked is not None:
-            assert_module_equivalence(
-                "rechecked" + str(step - 1), expected_rechecked, updated
-            )
+            assert_module_equivalence("rechecked" + str(step - 1), expected_rechecked, updated)
 
         expected = testcase.expected_fine_grained_targets.get(step)
         if expected:
@@ -277,9 +269,7 @@ class FineGrainedSuite(DataSuite):
         step N (2, 3, ...).
 
         """
-        m = re.search(
-            "# cmd: mypy ([a-zA-Z0-9_./ ]+)$", program_text, flags=re.MULTILINE
-        )
+        m = re.search("# cmd: mypy ([a-zA-Z0-9_./ ]+)$", program_text, flags=re.MULTILINE)
         regex = f"# cmd{incremental_step}: mypy ([a-zA-Z0-9_./ ]+)$"
         alt_m = re.search(regex, program_text, flags=re.MULTILINE)
         if alt_m is not None:
@@ -290,21 +280,15 @@ class FineGrainedSuite(DataSuite):
 
         if m:
             # The test case wants to use a non-default set of files.
-            paths = [
-                os.path.join(test_temp_dir, path) for path in m.group(1).strip().split()
-            ]
+            paths = [os.path.join(test_temp_dir, path) for path in m.group(1).strip().split()]
             return create_source_list(paths, options)
         else:
             base = BuildSource(os.path.join(test_temp_dir, "main"), "__main__", None)
             # Use expand_dir instead of create_source_list to avoid complaints
             # when there aren't any .py files in an increment
-            return [base] + create_source_list(
-                [test_temp_dir], options, allow_empty_dir=True
-            )
+            return [base] + create_source_list([test_temp_dir], options, allow_empty_dir=True)
 
-    def maybe_suggest(
-        self, step: int, server: Server, src: str, tmp_dir: str
-    ) -> list[str]:
+    def maybe_suggest(self, step: int, server: Server, src: str, tmp_dir: str) -> list[str]:
         output: list[str] = []
         targets = self.get_suggest(src, step)
         for flags, target in targets:
@@ -370,19 +354,13 @@ class FineGrainedSuite(DataSuite):
             output.extend(val.strip().split("\n"))
         return output
 
-    def get_suggest(
-        self, program_text: str, incremental_step: int
-    ) -> list[tuple[str, str]]:
+    def get_suggest(self, program_text: str, incremental_step: int) -> list[tuple[str, str]]:
         step_bit = "1?" if incremental_step == 1 else str(incremental_step)
-        regex = (
-            f"# suggest{step_bit}: (--[a-zA-Z0-9_\\-./=?^ ]+ )*([a-zA-Z0-9_.:/?^ ]+)$"
-        )
+        regex = f"# suggest{step_bit}: (--[a-zA-Z0-9_\\-./=?^ ]+ )*([a-zA-Z0-9_.:/?^ ]+)$"
         m = re.findall(regex, program_text, flags=re.MULTILINE)
         return m
 
-    def get_inspect(
-        self, program_text: str, incremental_step: int
-    ) -> list[tuple[str, str]]:
+    def get_inspect(self, program_text: str, incremental_step: int) -> list[tuple[str, str]]:
         step_bit = "1?" if incremental_step == 1 else str(incremental_step)
         regex = f"# inspect{step_bit}: (--[a-zA-Z0-9_\\-=?^ ]+ )*([a-zA-Z0-9_.:/?^ ]+)$"
         m = re.findall(regex, program_text, flags=re.MULTILINE)
@@ -395,20 +373,12 @@ def normalize_messages(messages: list[str]) -> list[str]:
 
 class TestMessageSorting(unittest.TestCase):
     def test_simple_sorting(self) -> None:
-        msgs = [
-            'x.py:1: error: "int" not callable',
-            'foo/y.py:123: note: "X" not defined',
-        ]
-        old_msgs = [
-            'foo/y.py:12: note: "Y" not defined',
-            'x.py:8: error: "str" not callable',
-        ]
-        assert sort_messages_preserving_file_order(msgs, old_msgs) == list(
+        msgs = ['x.py:1: error: "int" not callable', 'foo/y.py:123: note: "X" not defined']
+        old_msgs = ['foo/y.py:12: note: "Y" not defined', 'x.py:8: error: "str" not callable']
+        assert sort_messages_preserving_file_order(msgs, old_msgs) == list(reversed(msgs))
+        assert sort_messages_preserving_file_order(list(reversed(msgs)), old_msgs) == list(
             reversed(msgs)
         )
-        assert sort_messages_preserving_file_order(
-            list(reversed(msgs)), old_msgs
-        ) == list(reversed(msgs))
 
     def test_long_form_sorting(self) -> None:
         # Multi-line errors should be sorted together and not split.
@@ -423,10 +393,7 @@ class TestMessageSorting(unittest.TestCase):
             'foo/y.py:123: note: "X" not defined',
             "and again message continues",
         ]
-        old_msgs = [
-            'foo/y.py:12: note: "Y" not defined',
-            'x.py:8: error: "str" not callable',
-        ]
+        old_msgs = ['foo/y.py:12: note: "Y" not defined', 'x.py:8: error: "str" not callable']
         assert sort_messages_preserving_file_order(msg1 + msg2, old_msgs) == msg2 + msg1
         assert sort_messages_preserving_file_order(msg2 + msg1, old_msgs) == msg2 + msg1
 
@@ -457,18 +424,13 @@ class TestMessageSorting(unittest.TestCase):
         msg2 = 'foo/y.py:123: note: "X" not defined'
         new1 = "ab.py:3: error: Problem: error"
         new2 = "aaa:3: error: Bad"
-        old_msgs = [
-            'foo/y.py:12: note: "Y" not defined',
-            'x.py:8: error: "str" not callable',
-        ]
+        old_msgs = ['foo/y.py:12: note: "Y" not defined', 'x.py:8: error: "str" not callable']
         assert sort_messages_preserving_file_order([msg1, msg2, new1], old_msgs) == [
             msg2,
             msg1,
             new1,
         ]
-        assert sort_messages_preserving_file_order(
-            [new1, msg1, msg2, new2], old_msgs
-        ) == [
+        assert sort_messages_preserving_file_order([new1, msg1, msg2, new2], old_msgs) == [
             msg2,
             msg1,
             new1,

jaclang/vendor/mypy/test/testgraph.py

@@ -5,13 +5,7 @@ from __future__ import annotations
 import sys
 from typing import AbstractSet
 
-from mypy.build import (
-    BuildManager,
-    BuildSourceSet,
-    State,
-    order_ascc,
-    sorted_components,
-)
+from mypy.build import BuildManager, BuildSourceSet, State, order_ascc, sorted_components
 from mypy.errors import Errors
 from mypy.fscache import FileSystemCache
 from mypy.graph_utils import strongly_connected_components, topsort
@@ -29,22 +23,13 @@ class GraphSuite(Suite):
         b = frozenset({"B"})
         c = frozenset({"C"})
         d = frozenset({"D"})
-        data: dict[AbstractSet[str], set[AbstractSet[str]]] = {
-            a: {b, c},
-            b: {d},
-            c: {d},
-        }
+        data: dict[AbstractSet[str], set[AbstractSet[str]]] = {a: {b, c}, b: {d}, c: {d}}
         res = list(topsort(data))
         assert_equal(res, [{d}, {b, c}, {a}])
 
     def test_scc(self) -> None:
         vertices = {"A", "B", "C", "D"}
-        edges: dict[str, list[str]] = {
-            "A": ["B", "C"],
-            "B": ["C"],
-            "C": ["B", "D"],
-            "D": [],
-        }
+        edges: dict[str, list[str]] = {"A": ["B", "C"], "B": ["C"], "C": ["B", "D"], "D": []}
         sccs = {frozenset(x) for x in strongly_connected_components(vertices, edges)}
         assert_equal(sccs, {frozenset({"A"}), frozenset({"B", "C"}), frozenset({"D"})})