jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypy/test/testfinegrained.py

@@ -1,438 +0,0 @@
-"""Test cases for fine-grained incremental checking.
-
-Each test cases runs a batch build followed by one or more fine-grained
-incremental steps. We verify that each step produces the expected output.
-
-See the comment at the top of test-data/unit/fine-grained.test for more
-information.
-
-N.B.: Unlike most of the other test suites, testfinegrained does not
-rely on an alt_lib_path for finding source files. This means that they
-can test interactions with the lib_path that is built implicitly based
-on specified sources.
-"""
-
-from __future__ import annotations
-
-import os
-import re
-import unittest
-from typing import Any
-
-import pytest
-
-from mypy import build
-from mypy.config_parser import parse_config_file
-from mypy.dmypy_server import Server
-from mypy.dmypy_util import DEFAULT_STATUS_FILE
-from mypy.errors import CompileError
-from mypy.find_sources import create_source_list
-from mypy.modulefinder import BuildSource
-from mypy.options import Options
-from mypy.server.mergecheck import check_consistency
-from mypy.server.update import sort_messages_preserving_file_order
-from mypy.test.config import test_temp_dir
-from mypy.test.data import DataDrivenTestCase, DataSuite, DeleteFile, UpdateFile
-from mypy.test.helpers import (
-    assert_module_equivalence,
-    assert_string_arrays_equal,
-    assert_target_equivalence,
-    find_test_files,
-    parse_options,
-    perform_file_operations,
-)
-
-# Set to True to perform (somewhat expensive) checks for duplicate AST nodes after merge
-CHECK_CONSISTENCY = False
-
-
-class FineGrainedSuite(DataSuite):
-    files = find_test_files(
-        pattern="fine-grained*.test", exclude=["fine-grained-cache-incremental.test"]
-    )
-
-    # Whether to use the fine-grained cache in the testing. This is overridden
-    # by a trivial subclass to produce a suite that uses the cache.
-    use_cache = False
-
-    def should_skip(self, testcase: DataDrivenTestCase) -> bool:
-        # Decide whether to skip the test. This could have been structured
-        # as a filter() classmethod also, but we want the tests reported
-        # as skipped, not just elided.
-        if self.use_cache:
-            if testcase.only_when == "-only_when_nocache":
-                return True
-            # TODO: In caching mode we currently don't well support
-            # starting from cached states with errors in them.
-            if testcase.output and testcase.output[0] != "==":
-                return True
-        else:
-            if testcase.only_when == "-only_when_cache":
-                return True
-        return False
-
-    def run_case(self, testcase: DataDrivenTestCase) -> None:
-        if self.should_skip(testcase):
-            pytest.skip()
-            return
-
-        main_src = "\n".join(testcase.input)
-        main_path = os.path.join(test_temp_dir, "main")
-        with open(main_path, "w", encoding="utf8") as f:
-            f.write(main_src)
-
-        options = self.get_options(main_src, testcase, build_cache=False)
-        build_options = self.get_options(main_src, testcase, build_cache=True)
-        server = Server(options, DEFAULT_STATUS_FILE)
-
-        num_regular_incremental_steps = self.get_build_steps(main_src)
-        step = 1
-        sources = self.parse_sources(main_src, step, options)
-        if step <= num_regular_incremental_steps:
-            messages = self.build(build_options, sources)
-        else:
-            messages = self.run_check(server, sources)
-
-        a = []
-        if messages:
-            a.extend(normalize_messages(messages))
-
-        assert testcase.tmpdir
-        a.extend(self.maybe_suggest(step, server, main_src, testcase.tmpdir.name))
-        a.extend(self.maybe_inspect(step, server, main_src))
-
-        if server.fine_grained_manager:
-            if CHECK_CONSISTENCY:
-                check_consistency(server.fine_grained_manager)
-
-        steps = testcase.find_steps()
-        all_triggered = []
-
-        for operations in steps:
-            step += 1
-            output, triggered = self.perform_step(
-                operations,
-                server,
-                options,
-                build_options,
-                testcase,
-                main_src,
-                step,
-                num_regular_incremental_steps,
-            )
-            a.append("==")
-            a.extend(output)
-            all_triggered.extend(triggered)
-
-        # Normalize paths in test output (for Windows).
-        a = [line.replace("\\", "/") for line in a]
-
-        assert_string_arrays_equal(
-            testcase.output, a, f"Invalid output ({testcase.file}, line {testcase.line})"
-        )
-
-        if testcase.triggered:
-            assert_string_arrays_equal(
-                testcase.triggered,
-                self.format_triggered(all_triggered),
-                f"Invalid active triggers ({testcase.file}, line {testcase.line})",
-            )
-
-    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
-        options.use_builtins_fixtures = True
-        options.show_traceback = True
-        options.error_summary = False
-        options.fine_grained_incremental = not build_cache
-        options.use_fine_grained_cache = self.use_cache and not build_cache
-        options.cache_fine_grained = self.use_cache
-        options.local_partial_types = True
-        options.export_types = "inspect" in testcase.file
-        # Treat empty bodies safely for these test cases.
-        options.allow_empty_bodies = not testcase.name.endswith("_no_empty")
-        if re.search("flags:.*--follow-imports", source) is None:
-            # Override the default for follow_imports
-            options.follow_imports = "error"
-
-        for name, _ in testcase.files:
-            if "mypy.ini" in name or "pyproject.toml" in name:
-                parse_config_file(options, lambda: None, name)
-                break
-
-        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)
-        out = response["out"] or response["err"]
-        assert isinstance(out, str)
-        return out.splitlines()
-
-    def build(self, options: Options, sources: list[BuildSource]) -> list[str]:
-        try:
-            result = build.build(sources=sources, options=options)
-        except CompileError as e:
-            return e.messages
-        return result.errors
-
-    def format_triggered(self, triggered: list[list[str]]) -> list[str]:
-        result = []
-        for n, triggers in enumerate(triggered):
-            filtered = [trigger for trigger in triggers if not trigger.endswith("__>")]
-            filtered = sorted(filtered)
-            result.append(("%d: %s" % (n + 2, ", ".join(filtered))).strip())
-        return result
-
-    def get_build_steps(self, program_text: str) -> int:
-        """Get the number of regular incremental steps to run, from the test source"""
-        if not self.use_cache:
-            return 0
-        m = re.search("# num_build_steps: ([0-9]+)$", program_text, flags=re.MULTILINE)
-        if m is not None:
-            return int(m.group(1))
-        return 1
-
-    def perform_step(
-        self,
-        operations: list[UpdateFile | DeleteFile],
-        server: Server,
-        options: Options,
-        build_options: Options,
-        testcase: DataDrivenTestCase,
-        main_src: str,
-        step: int,
-        num_regular_incremental_steps: int,
-    ) -> tuple[list[str], list[list[str]]]:
-        """Perform one fine-grained incremental build step (after some file updates/deletions).
-
-        Return (mypy output, triggered targets).
-        """
-        perform_file_operations(operations)
-        sources = self.parse_sources(main_src, step, options)
-
-        if step <= num_regular_incremental_steps:
-            new_messages = self.build(build_options, sources)
-        else:
-            new_messages = self.run_check(server, sources)
-
-        updated: list[str] = []
-        changed: list[str] = []
-        targets: list[str] = []
-        triggered = []
-        if server.fine_grained_manager:
-            if CHECK_CONSISTENCY:
-                check_consistency(server.fine_grained_manager)
-            triggered.append(server.fine_grained_manager.triggered)
-
-            updated = server.fine_grained_manager.updated_modules
-            changed = [mod for mod, file in server.fine_grained_manager.changed_modules]
-            targets = server.fine_grained_manager.processed_targets
-
-        expected_stale = testcase.expected_stale_modules.get(step - 1)
-        if expected_stale is not None:
-            assert_module_equivalence("stale" + str(step - 1), expected_stale, changed)
-
-        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)
-
-        expected = testcase.expected_fine_grained_targets.get(step)
-        if expected:
-            assert_target_equivalence("targets" + str(step), expected, targets)
-
-        new_messages = normalize_messages(new_messages)
-
-        a = new_messages
-        assert testcase.tmpdir
-        a.extend(self.maybe_suggest(step, server, main_src, testcase.tmpdir.name))
-        a.extend(self.maybe_inspect(step, server, main_src))
-
-        return a, triggered
-
-    def parse_sources(
-        self, program_text: str, incremental_step: int, options: Options
-    ) -> list[BuildSource]:
-        """Return target BuildSources for a test case.
-
-        Normally, the unit tests will check all files included in the test
-        case. This differs from how testcheck works by default, as dmypy
-        doesn't currently support following imports.
-
-        You can override this behavior and instruct the tests to check
-        multiple modules by using a comment like this in the test case
-        input:
-
-          # cmd: main a.py
-
-        You can also use `# cmdN:` to have a different cmd for incremental
-        step N (2, 3, ...).
-
-        """
-        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:
-            # Optionally return a different command if in a later step
-            # of incremental mode, otherwise default to reusing the
-            # original cmd.
-            m = alt_m
-
-        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()]
-            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)
-
-    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:
-            json = "--json" in flags
-            callsites = "--callsites" in flags
-            no_any = "--no-any" in flags
-            no_errors = "--no-errors" in flags
-            m = re.match("--flex-any=([0-9.]+)", flags)
-            flex_any = float(m.group(1)) if m else None
-            m = re.match(r"--use-fixme=(\w+)", flags)
-            use_fixme = m.group(1) if m else None
-            m = re.match("--max-guesses=([0-9]+)", flags)
-            max_guesses = int(m.group(1)) if m else None
-            res: dict[str, Any] = server.cmd_suggest(
-                target.strip(),
-                json=json,
-                no_any=no_any,
-                no_errors=no_errors,
-                flex_any=flex_any,
-                use_fixme=use_fixme,
-                callsites=callsites,
-                max_guesses=max_guesses,
-            )
-            val = res["error"] if "error" in res else res["out"] + res["err"]
-            if json:
-                # JSON contains already escaped \ on Windows, so requires a bit of care.
-                val = val.replace("\\\\", "\\")
-                val = val.replace(os.path.realpath(tmp_dir) + os.path.sep, "")
-                val = val.replace(os.path.abspath(tmp_dir) + os.path.sep, "")
-            output.extend(val.strip().split("\n"))
-        return normalize_messages(output)
-
-    def maybe_inspect(self, step: int, server: Server, src: str) -> list[str]:
-        output: list[str] = []
-        targets = self.get_inspect(src, step)
-        for flags, location in targets:
-            m = re.match(r"--show=(\w+)", flags)
-            show = m.group(1) if m else "type"
-            verbosity = 0
-            if "-v" in flags:
-                verbosity = 1
-            if "-vv" in flags:
-                verbosity = 2
-            m = re.match(r"--limit=([0-9]+)", flags)
-            limit = int(m.group(1)) if m else 0
-            include_span = "--include-span" in flags
-            include_kind = "--include-kind" in flags
-            include_object_attrs = "--include-object-attrs" in flags
-            union_attrs = "--union-attrs" in flags
-            force_reload = "--force-reload" in flags
-            res: dict[str, Any] = server.cmd_inspect(
-                show,
-                location,
-                verbosity=verbosity,
-                limit=limit,
-                include_span=include_span,
-                include_kind=include_kind,
-                include_object_attrs=include_object_attrs,
-                union_attrs=union_attrs,
-                force_reload=force_reload,
-            )
-            val = res["error"] if "error" in res else res["out"] + res["err"]
-            output.extend(val.strip().split("\n"))
-        return output
-
-    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_.:/?^ ]+)$"
-        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]]:
-        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)
-        return m
-
-
-def normalize_messages(messages: list[str]) -> list[str]:
-    return [re.sub("^tmp" + re.escape(os.sep), "", message) for message in messages]
-
-
-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(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.
-        msg1 = [
-            'x.py:1: error: "int" not callable',
-            "and message continues (x: y)",
-            "    1()",
-            "    ^~~",
-        ]
-        msg2 = [
-            'foo/y.py: In function "f":',
-            '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']
-        assert sort_messages_preserving_file_order(msg1 + msg2, old_msgs) == msg2 + msg1
-        assert sort_messages_preserving_file_order(msg2 + msg1, old_msgs) == msg2 + msg1
-
-    def test_mypy_error_prefix(self) -> None:
-        # Some errors don't have a file and start with "mypy: ". These
-        # shouldn't be sorted together with file-specific errors.
-        msg1 = 'x.py:1: error: "int" not callable'
-        msg2 = 'foo/y:123: note: "X" not defined'
-        msg3 = "mypy: Error not associated with a file"
-        old_msgs = [
-            "mypy: Something wrong",
-            'foo/y:12: note: "Y" not defined',
-            'x.py:8: error: "str" not callable',
-        ]
-        assert sort_messages_preserving_file_order([msg1, msg2, msg3], old_msgs) == [
-            msg2,
-            msg1,
-            msg3,
-        ]
-        assert sort_messages_preserving_file_order([msg3, msg2, msg1], old_msgs) == [
-            msg2,
-            msg1,
-            msg3,
-        ]
-
-    def test_new_file_at_the_end(self) -> None:
-        msg1 = 'x.py:1: error: "int" not callable'
-        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']
-        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) == [
-            msg2,
-            msg1,
-            new1,
-            new2,
-        ]

jaclang/vendor/mypy/test/testfinegrainedcache.py

@@ -1,18 +0,0 @@
-"""Tests for fine-grained incremental checking using the cache.
-
-All of the real code for this lives in testfinegrained.py.
-"""
-
-# We can't "import FineGrainedSuite from ..." because that will cause pytest
-# to collect the non-caching tests when running this file.
-from __future__ import annotations
-
-import mypy.test.testfinegrained
-
-
-class FineGrainedCacheSuite(mypy.test.testfinegrained.FineGrainedSuite):
-    use_cache = True
-    test_name_suffix = "_cached"
-    files = mypy.test.testfinegrained.FineGrainedSuite.files + [
-        "fine-grained-cache-incremental.test"
-    ]

jaclang/vendor/mypy/test/testformatter.py

@@ -1,85 +0,0 @@
-from __future__ import annotations
-
-from unittest import TestCase, main
-
-from mypy.util import split_words, trim_source_line
-
-
-class FancyErrorFormattingTestCases(TestCase):
-    def test_trim_source(self) -> None:
-        assert trim_source_line("0123456789abcdef", max_len=16, col=5, min_width=2) == (
-            "0123456789abcdef",
-            0,
-        )
-
-        # Locations near start.
-        assert trim_source_line("0123456789abcdef", max_len=7, col=0, min_width=2) == (
-            "0123456...",
-            0,
-        )
-        assert trim_source_line("0123456789abcdef", max_len=7, col=4, min_width=2) == (
-            "0123456...",
-            0,
-        )
-
-        # Middle locations.
-        assert trim_source_line("0123456789abcdef", max_len=7, col=5, min_width=2) == (
-            "...1234567...",
-            -2,
-        )
-        assert trim_source_line("0123456789abcdef", max_len=7, col=6, min_width=2) == (
-            "...2345678...",
-            -1,
-        )
-        assert trim_source_line("0123456789abcdef", max_len=7, col=8, min_width=2) == (
-            "...456789a...",
-            1,
-        )
-
-        # Locations near the end.
-        assert trim_source_line("0123456789abcdef", max_len=7, col=11, min_width=2) == (
-            "...789abcd...",
-            4,
-        )
-        assert trim_source_line("0123456789abcdef", max_len=7, col=13, min_width=2) == (
-            "...9abcdef",
-            6,
-        )
-        assert trim_source_line("0123456789abcdef", max_len=7, col=15, min_width=2) == (
-            "...9abcdef",
-            6,
-        )
-
-    def test_split_words(self) -> None:
-        assert split_words("Simple message") == ["Simple", "message"]
-        assert split_words('Message with "Some[Long, Types]" in it') == [
-            "Message",
-            "with",
-            '"Some[Long, Types]"',
-            "in",
-            "it",
-        ]
-        assert split_words('Message with "Some[Long, Types]" and [error-code]') == [
-            "Message",
-            "with",
-            '"Some[Long, Types]"',
-            "and",
-            "[error-code]",
-        ]
-        assert split_words('"Type[Stands, First]" then words') == [
-            '"Type[Stands, First]"',
-            "then",
-            "words",
-        ]
-        assert split_words('First words "Then[Stands, Type]"') == [
-            "First",
-            "words",
-            '"Then[Stands, Type]"',
-        ]
-        assert split_words('"Type[Only, Here]"') == ['"Type[Only, Here]"']
-        assert split_words("OneWord") == ["OneWord"]
-        assert split_words(" ") == ["", ""]
-
-
-if __name__ == "__main__":
-    main()

jaclang/vendor/mypy/test/testfscache.py

@@ -1,101 +0,0 @@
-"""Unit tests for file system cache."""
-
-from __future__ import annotations
-
-import os
-import shutil
-import sys
-import tempfile
-import unittest
-
-from mypy.fscache import FileSystemCache
-
-
-class TestFileSystemCache(unittest.TestCase):
-    def setUp(self) -> None:
-        self.tempdir = tempfile.mkdtemp()
-        self.oldcwd = os.getcwd()
-        os.chdir(self.tempdir)
-        self.fscache = FileSystemCache()
-
-    def tearDown(self) -> None:
-        os.chdir(self.oldcwd)
-        shutil.rmtree(self.tempdir)
-
-    def test_isfile_case_1(self) -> None:
-        self.make_file("bar.py")
-        self.make_file("pkg/sub_package/__init__.py")
-        self.make_file("pkg/sub_package/foo.py")
-        # Run twice to test both cached and non-cached code paths.
-        for i in range(2):
-            assert self.isfile_case("bar.py")
-            assert self.isfile_case("pkg/sub_package/__init__.py")
-            assert self.isfile_case("pkg/sub_package/foo.py")
-            assert not self.isfile_case("non_existent.py")
-            assert not self.isfile_case("pkg/non_existent.py")
-            assert not self.isfile_case("pkg/")
-            assert not self.isfile_case("bar.py/")
-        for i in range(2):
-            assert not self.isfile_case("Bar.py")
-            assert not self.isfile_case("pkg/sub_package/__init__.PY")
-            assert not self.isfile_case("pkg/Sub_Package/foo.py")
-            assert not self.isfile_case("Pkg/sub_package/foo.py")
-
-    def test_isfile_case_2(self) -> None:
-        self.make_file("bar.py")
-        self.make_file("pkg/sub_package/__init__.py")
-        self.make_file("pkg/sub_package/foo.py")
-        # Run twice to test both cached and non-cached code paths.
-        # This reverses the order of checks from test_isfile_case_1.
-        for i in range(2):
-            assert not self.isfile_case("Bar.py")
-            assert not self.isfile_case("pkg/sub_package/__init__.PY")
-            assert not self.isfile_case("pkg/Sub_Package/foo.py")
-            assert not self.isfile_case("Pkg/sub_package/foo.py")
-        for i in range(2):
-            assert self.isfile_case("bar.py")
-            assert self.isfile_case("pkg/sub_package/__init__.py")
-            assert self.isfile_case("pkg/sub_package/foo.py")
-            assert not self.isfile_case("non_existent.py")
-            assert not self.isfile_case("pkg/non_existent.py")
-
-    def test_isfile_case_3(self) -> None:
-        self.make_file("bar.py")
-        self.make_file("pkg/sub_package/__init__.py")
-        self.make_file("pkg/sub_package/foo.py")
-        # Run twice to test both cached and non-cached code paths.
-        for i in range(2):
-            assert self.isfile_case("bar.py")
-            assert not self.isfile_case("non_existent.py")
-            assert not self.isfile_case("pkg/non_existent.py")
-            assert not self.isfile_case("Bar.py")
-            assert not self.isfile_case("pkg/sub_package/__init__.PY")
-            assert not self.isfile_case("pkg/Sub_Package/foo.py")
-            assert not self.isfile_case("Pkg/sub_package/foo.py")
-            assert self.isfile_case("pkg/sub_package/__init__.py")
-            assert self.isfile_case("pkg/sub_package/foo.py")
-
-    def test_isfile_case_other_directory(self) -> None:
-        self.make_file("bar.py")
-        with tempfile.TemporaryDirectory() as other:
-            self.make_file("other_dir.py", base=other)
-            self.make_file("pkg/other_dir.py", base=other)
-            assert self.isfile_case(os.path.join(other, "other_dir.py"))
-            assert not self.isfile_case(os.path.join(other, "Other_Dir.py"))
-            assert not self.isfile_case(os.path.join(other, "bar.py"))
-            if sys.platform in ("win32", "darwin"):
-                # We only check case for directories under our prefix, and since
-                # this path is not under the prefix, case difference is fine.
-                assert self.isfile_case(os.path.join(other, "PKG/other_dir.py"))
-
-    def make_file(self, path: str, base: str | None = None) -> None:
-        if base is None:
-            base = self.tempdir
-        fullpath = os.path.join(base, path)
-        os.makedirs(os.path.dirname(fullpath), exist_ok=True)
-        if not path.endswith("/"):
-            with open(fullpath, "w") as f:
-                f.write("# test file")
-
-    def isfile_case(self, path: str) -> bool:
-        return self.fscache.isfile_case(os.path.join(self.tempdir, path), self.tempdir)