diff --git a/docs/source/command_line.rst b/docs/source/command_line.rst
index 40df775742a6..db4da1436189 100644
--- a/docs/source/command_line.rst
+++ b/docs/source/command_line.rst
@@ -49,6 +49,30 @@ for full details, see :ref:`running-mypy`.
     Asks mypy to type check the provided string as a program.
 
 
+.. option:: --exclude
+
+    A regular expression that matches file names, directory names and paths
+    which mypy should ignore while recursively discovering files to check.
+    Use forward slashes on all platforms.
+
+    For instance, to avoid discovering any files named `setup.py` you could
+    pass ``--exclude '/setup\.py$'``. Similarly, you can ignore discovering
+    directories with a given name by e.g. ``--exclude /build/`` or
+    those matching a subpath with ``--exclude /project/vendor/``.
+
+    Note that this flag only affects recursive discovery, that is, when mypy is
+    discovering files within a directory tree or submodules of a package to
+    check. If you pass a file or module explicitly it will still be checked. For
+    instance, ``mypy --exclude '/setup.py$' but_still_check/setup.py``.
+
+    Note that mypy will never recursively discover files and directories named
+    "site-packages", "node_modules" or "__pycache__", or those whose name starts
+    with a period, exactly as ``--exclude
+    '/(site-packages|node_modules|__pycache__|\..*)/$'`` would. Mypy will also
+    never recursively discover files with extensions other than ``.py`` or
+    ``.pyi``.
+
+
 Optional arguments
 ******************
 
diff --git a/docs/source/config_file.rst b/docs/source/config_file.rst
index 11aa73fbf5d0..6ae02fe8aa52 100644
--- a/docs/source/config_file.rst
+++ b/docs/source/config_file.rst
@@ -192,6 +192,18 @@ section of the command line docs.
 
     This option may only be set in the global section (``[mypy]``).
 
+.. confval:: exclude
+
+    :type: regular expression
+
+    A regular expression that matches file names, directory names and paths
+    which mypy should ignore while recursively discovering files to check.
+    Use forward slashes on all platforms.
+
+    For more details, see :option:`--exclude <mypy --exclude>`.
+
+    This option may only be set in the global section (``[mypy]``).
+
 .. confval:: namespace_packages
 
     :type: boolean
diff --git a/docs/source/running_mypy.rst b/docs/source/running_mypy.rst
index 3d5b9ff6d17a..2c1d14b6d858 100644
--- a/docs/source/running_mypy.rst
+++ b/docs/source/running_mypy.rst
@@ -355,7 +355,8 @@ to modules to type check.
 - Mypy will check all paths provided that correspond to files.
 
 - Mypy will recursively discover and check all files ending in ``.py`` or
-  ``.pyi`` in directory paths provided.
+  ``.pyi`` in directory paths provided, after accounting for
+  :option:`--exclude <mypy --exclude>`.
 
 - For each file to be checked, mypy will attempt to associate the file (e.g.
   ``project/foo/bar/baz.py``) with a fully qualified module name (e.g.
diff --git a/misc/build_wheel.py b/misc/build_wheel.py
new file mode 100644
index 000000000000..13633405bf77
--- /dev/null
+++ b/misc/build_wheel.py
@@ -0,0 +1,131 @@
+"""Script to build compiled binary wheels that can be uploaded to PyPI.
+
+The main GitHub workflow where this script is used:
+https://github.com/mypyc/mypy_mypyc-wheels/blob/master/.github/workflows/build.yml
+
+This uses cibuildwheel (https://github.com/joerick/cibuildwheel) to
+build the wheels.
+
+Usage:
+
+  build_wheel_ci.py --python-version <python-version> \
+                    --output-dir <dir>
+
+Wheels for the given Python version will be created in the given directory.
+Python version is in form "39".
+
+This works on macOS, Windows and Linux.
+
+You can test locally by using --extra-opts. macOS example:
+
+  mypy/misc/build_wheel_ci.py --python-version 39 --output-dir out --extra-opts="--platform macos"
+
+Other supported values for platform: linux, windows
+"""
+
+import argparse
+import os
+import subprocess
+import sys
+from typing import Dict
+
+# Clang package we use on Linux
+LLVM_URL = 'https://github.com/mypyc/mypy_mypyc-wheels/releases/download/llvm/llvm-centos-5.tar.gz'
+
+# Mypy repository root
+ROOT_DIR = os.path.dirname(os.path.dirname(__file__))
+
+
+def create_environ(python_version: str) -> Dict[str, str]:
+    """Set up environment variables for cibuildwheel."""
+    env = os.environ.copy()
+
+    env['CIBW_BUILD'] = "cp{}-*".format(python_version)
+
+    # Don't build 32-bit wheels
+    env['CIBW_SKIP'] = "*-manylinux_i686 *-win32"
+
+    env['CIBW_BUILD_VERBOSITY'] = '1'
+
+    # mypy's isolated builds don't specify the requirements mypyc needs, so install
+    # requirements and don't use isolated builds. we need to use build-requirements.txt
+    # with recent mypy commits to get stub packages needed for compilation.
+    #
+    # TODO: remove use of mypy-requirements.txt once we no longer need to support
+    #       building pre modular typeshed releases
+    env['CIBW_BEFORE_BUILD'] = """
+      pip install -r {package}/mypy-requirements.txt &&
+      (pip install -r {package}/build-requirements.txt || true)
+    """.replace('\n', ' ')
+
+    # download a copy of clang to use to compile on linux. this was probably built in 2018,
+    # speeds up compilation 2x
+    env['CIBW_BEFORE_BUILD_LINUX'] = """
+      (cd / && curl -L %s | tar xzf -) &&
+      pip install -r {package}/mypy-requirements.txt &&
+      (pip install -r {package}/build-requirements.txt || true)
+    """.replace('\n', ' ') % LLVM_URL
+
+    # the double negative is counterintuitive, https://github.com/pypa/pip/issues/5735
+    env['CIBW_ENVIRONMENT'] = 'MYPY_USE_MYPYC=1 MYPYC_OPT_LEVEL=3 PIP_NO_BUILD_ISOLATION=no'
+    env['CIBW_ENVIRONMENT_LINUX'] = (
+        'MYPY_USE_MYPYC=1 MYPYC_OPT_LEVEL=3 PIP_NO_BUILD_ISOLATION=no ' +
+        'CC=/opt/llvm/bin/clang'
+    )
+    env['CIBW_ENVIRONMENT_WINDOWS'] = (
+        'MYPY_USE_MYPYC=1 MYPYC_OPT_LEVEL=2 PIP_NO_BUILD_ISOLATION=no'
+    )
+
+    # lxml is slow to build wheels for new releases, so allow installing reqs to fail
+    # if we failed to install lxml, we'll skip tests, but allow the build to succeed
+    env['CIBW_BEFORE_TEST'] = (
+        'pip install -r {project}/mypy/test-requirements.txt || true'
+    )
+
+    # pytest looks for configuration files in the parent directories of where the tests live.
+    # since we are trying to run the tests from their installed location, we copy those into
+    # the venv. Ew ew ew.
+    env['CIBW_TEST_COMMAND'] = """
+      ( ! pip list | grep lxml ) || (
+      DIR=$(python -c 'import mypy, os; dn = os.path.dirname; print(dn(dn(mypy.__path__[0])))')
+      && TEST_DIR=$(python -c 'import mypy.test; print(mypy.test.__path__[0])')
+      && cp '{project}/mypy/pytest.ini' '{project}/mypy/conftest.py' $DIR
+      && MYPY_TEST_PREFIX='{project}/mypy' pytest $TEST_DIR
+      )
+    """.replace('\n', ' ')
+
+    # i ran into some flaky tests on windows, so only run testcheck. it looks like we
+    # previously didn't run any tests on windows wheels, so this is a net win.
+    env['CIBW_TEST_COMMAND_WINDOWS'] = """
+      bash -c "
+      ( ! pip list | grep lxml ) || (
+      DIR=$(python -c 'import mypy, os; dn = os.path.dirname; print(dn(dn(mypy.__path__[0])))')
+      && TEST_DIR=$(python -c 'import mypy.test; print(mypy.test.__path__[0])')
+      && cp '{project}/mypy/pytest.ini' '{project}/mypy/conftest.py' $DIR
+      && MYPY_TEST_PREFIX='{project}/mypy' pytest $TEST_DIR/testcheck.py
+      )
+      "
+    """.replace('\n', ' ')
+    return env
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--python-version', required=True, metavar='XY',
+                        help='Python version (e.g. 38 or 39)')
+    parser.add_argument('--output-dir', required=True, metavar='DIR',
+                        help='Output directory for created wheels')
+    parser.add_argument('--extra-opts', default='', metavar='OPTIONS',
+                        help='Extra options passed to cibuildwheel verbatim')
+    args = parser.parse_args()
+    python_version = args.python_version
+    output_dir = args.output_dir
+    extra_opts = args.extra_opts
+    environ = create_environ(python_version)
+    script = 'python -m cibuildwheel {} --output-dir {} {}'.format(extra_opts, output_dir,
+                                                                   ROOT_DIR)
+    subprocess.check_call(script, shell=True, env=environ)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mypy/build.py b/mypy/build.py
index e6f597af31bc..324a8f853456 100644
--- a/mypy/build.py
+++ b/mypy/build.py
@@ -15,7 +15,6 @@
 import gc
 import json
 import os
-import pathlib
 import re
 import stat
 import sys
@@ -2552,6 +2551,7 @@ def log_configuration(manager: BuildManager, sources: List[BuildSource]) -> None
         ("Current Executable", sys.executable),
         ("Cache Dir", manager.options.cache_dir),
         ("Compiled", str(not __file__.endswith(".py"))),
+        ("Exclude", manager.options.exclude),
     ]
 
     for conf_name, conf_value in configuration_vars:
@@ -2751,14 +2751,12 @@ def load_graph(sources: List[BuildSource], manager: BuildManager,
                 "Duplicate module named '%s' (also at '%s')" % (st.id, graph[st.id].xpath),
                 blocker=True,
             )
-            p1 = len(pathlib.PurePath(st.xpath).parents)
-            p2 = len(pathlib.PurePath(graph[st.id].xpath).parents)
-
-            if p1 != p2:
-                manager.errors.report(
-                    -1, -1,
-                    "Are you missing an __init__.py?"
-                )
+            manager.errors.report(
+                -1, -1,
+                "Are you missing an __init__.py? Alternatively, consider using --exclude to "
+                "avoid checking one of them.",
+                severity='note'
+            )
 
             manager.errors.raise_error()
         graph[st.id] = st
diff --git a/mypy/find_sources.py b/mypy/find_sources.py
index 47d686cddcbc..4f50d8ff52b2 100644
--- a/mypy/find_sources.py
+++ b/mypy/find_sources.py
@@ -6,7 +6,7 @@
 from typing import List, Sequence, Set, Tuple, Optional
 from typing_extensions import Final
 
-from mypy.modulefinder import BuildSource, PYTHON_EXTENSIONS, mypy_path
+from mypy.modulefinder import BuildSource, PYTHON_EXTENSIONS, mypy_path, matches_exclude
 from mypy.fscache import FileSystemCache
 from mypy.options import Options
 
@@ -91,6 +91,8 @@ def __init__(self, fscache: FileSystemCache, options: Options) -> None:
         self.fscache = fscache
         self.explicit_package_bases = get_explicit_package_bases(options)
         self.namespace_packages = options.namespace_packages
+        self.exclude = options.exclude
+        self.verbosity = options.verbosity
 
     def is_explicit_package_base(self, path: str) -> bool:
         assert self.explicit_package_bases
@@ -103,10 +105,15 @@ def find_sources_in_dir(self, path: str) -> List[BuildSource]:
         names = sorted(self.fscache.listdir(path), key=keyfunc)
         for name in names:
             # Skip certain names altogether
-            if name == '__pycache__' or name.startswith('.') or name.endswith('~'):
+            if name in ("__pycache__", "site-packages", "node_modules") or name.startswith("."):
                 continue
             subpath = os.path.join(path, name)
 
+            if matches_exclude(
+                subpath, self.exclude, self.fscache, self.verbosity >= 2
+            ):
+                continue
+
             if self.fscache.isdir(subpath):
                 sub_sources = self.find_sources_in_dir(subpath)
                 if sub_sources:
diff --git a/mypy/main.py b/mypy/main.py
index ab38f7478b3f..ea68ee41d0f2 100644
--- a/mypy/main.py
+++ b/mypy/main.py
@@ -791,6 +791,15 @@ def add_invertible_flag(flag: str,
     code_group.add_argument(
         '--explicit-package-bases', action='store_true',
         help="Use current directory and MYPYPATH to determine module names of files passed")
+    code_group.add_argument(
+        "--exclude",
+        metavar="PATTERN",
+        default="",
+        help=(
+            "Regular expression to match file names, directory names or paths which mypy should "
+            "ignore while recursively discovering files to check, e.g. --exclude '/setup\\.py$'"
+        )
+    )
     code_group.add_argument(
         '-m', '--module', action='append', metavar='MODULE',
         default=[],
diff --git a/mypy/modulefinder.py b/mypy/modulefinder.py
index bdc71d7a7e58..82d090702cfc 100644
--- a/mypy/modulefinder.py
+++ b/mypy/modulefinder.py
@@ -7,6 +7,7 @@
 import collections
 import functools
 import os
+import re
 import subprocess
 import sys
 from enum import Enum
@@ -380,10 +381,15 @@ def find_modules_recursive(self, module: str) -> List[BuildSource]:
         names = sorted(self.fscache.listdir(package_path))
         for name in names:
             # Skip certain names altogether
-            if name == '__pycache__' or name.startswith('.') or name.endswith('~'):
+            if name in ("__pycache__", "site-packages", "node_modules") or name.startswith("."):
                 continue
             subpath = os.path.join(package_path, name)
 
+            if self.options and matches_exclude(
+                subpath, self.options.exclude, self.fscache, self.options.verbosity >= 2
+            ):
+                continue
+
             if self.fscache.isdir(subpath):
                 # Only recurse into packages
                 if (self.options and self.options.namespace_packages) or (
@@ -397,13 +403,26 @@ def find_modules_recursive(self, module: str) -> List[BuildSource]:
                 if stem == '__init__':
                     continue
                 if stem not in seen and '.' not in stem and suffix in PYTHON_EXTENSIONS:
-                    # (If we sorted names) we could probably just make the BuildSource ourselves,
-                    # but this ensures compatibility with find_module / the cache
+                    # (If we sorted names by keyfunc) we could probably just make the BuildSource
+                    # ourselves, but this ensures compatibility with find_module / the cache
                     seen.add(stem)
                     sources.extend(self.find_modules_recursive(module + '.' + stem))
         return sources
 
 
+def matches_exclude(subpath: str, exclude: str, fscache: FileSystemCache, verbose: bool) -> bool:
+    if not exclude:
+        return False
+    subpath_str = os.path.relpath(subpath).replace(os.sep, "/")
+    if fscache.isdir(subpath):
+        subpath_str += "/"
+    if re.search(exclude, subpath_str):
+        if verbose:
+            print("TRACE: Excluding {}".format(subpath_str), file=sys.stderr)
+        return True
+    return False
+
+
 def verify_module(fscache: FileSystemCache, id: str, path: str, prefix: str) -> bool:
     """Check that all packages containing id have a __init__ file."""
     if path.endswith(('__init__.py', '__init__.pyi')):
diff --git a/mypy/options.py b/mypy/options.py
index e95ed3e0bb46..752e1cffdb25 100644
--- a/mypy/options.py
+++ b/mypy/options.py
@@ -97,6 +97,8 @@ def __init__(self) -> None:
         # sufficient to determine module names for files. As a possible alternative, add a single
         # top-level __init__.py to your packages.
         self.explicit_package_bases = False
+        # File names, directory names or subpaths to avoid checking
+        self.exclude = ""  # type: str
 
         # disallow_any options
         self.disallow_any_generics = False
diff --git a/mypy/test/test_find_sources.py b/mypy/test/test_find_sources.py
index 5cedec338bbc..ba5b613a0948 100644
--- a/mypy/test/test_find_sources.py
+++ b/mypy/test/test_find_sources.py
@@ -1,11 +1,15 @@
-from mypy.modulefinder import BuildSource
 import os
+import pytest
+import shutil
+import tempfile
 import unittest
 from typing import List, Optional, Set, Tuple
-from mypy.find_sources import SourceFinder
+
+from mypy.find_sources import InvalidSourceList, SourceFinder, create_source_list
 from mypy.fscache import FileSystemCache
 from mypy.modulefinder import BuildSource
 from mypy.options import Options
+from mypy.modulefinder import BuildSource
 
 
 class FakeFSCache(FileSystemCache):
@@ -47,11 +51,27 @@ def crawl(finder: SourceFinder, f: str) -> Tuple[str, str]:
     return module, normalise_path(base_dir)
 
 
-def find_sources(finder: SourceFinder, f: str) -> List[Tuple[str, Optional[str]]]:
+def find_sources_in_dir(finder: SourceFinder, f: str) -> List[Tuple[str, Optional[str]]]:
     return normalise_build_source_list(finder.find_sources_in_dir(os.path.abspath(f)))
 
 
+def find_sources(
+    paths: List[str], options: Options, fscache: FileSystemCache
+) -> List[Tuple[str, Optional[str]]]:
+    paths = [os.path.abspath(p) for p in paths]
+    return normalise_build_source_list(create_source_list(paths, options, fscache))
+
+
 class SourceFinderSuite(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tempdir = tempfile.mkdtemp()
+        self.oldcwd = os.getcwd()
+        os.chdir(self.tempdir)
+
+    def tearDown(self) -> None:
+        os.chdir(self.oldcwd)
+        shutil.rmtree(self.tempdir)
+
     def test_crawl_no_namespace(self) -> None:
         options = Options()
         options.namespace_packages = False
@@ -172,7 +192,7 @@ def test_crawl_namespace_multi_dir(self) -> None:
         assert crawl(finder, "/a/pkg/a.py") == ("pkg.a", "/a")
         assert crawl(finder, "/b/pkg/b.py") == ("pkg.b", "/b")
 
-    def test_find_sources_no_namespace(self) -> None:
+    def test_find_sources_in_dir_no_namespace(self) -> None:
         options = Options()
         options.namespace_packages = False
 
@@ -184,7 +204,7 @@ def test_find_sources_no_namespace(self) -> None:
             "/pkg/a2/b/f.py",
         }
         finder = SourceFinder(FakeFSCache(files), options)
-        assert find_sources(finder, "/") == [
+        assert find_sources_in_dir(finder, "/") == [
             ("a2", "/pkg"),
             ("e", "/pkg/a1/b/c/d"),
             ("e", "/pkg/a2/b/c/d"),
@@ -192,7 +212,7 @@ def test_find_sources_no_namespace(self) -> None:
             ("f", "/pkg/a2/b"),
         ]
 
-    def test_find_sources_namespace(self) -> None:
+    def test_find_sources_in_dir_namespace(self) -> None:
         options = Options()
         options.namespace_packages = True
 
@@ -204,7 +224,7 @@ def test_find_sources_namespace(self) -> None:
             "/pkg/a2/b/f.py",
         }
         finder = SourceFinder(FakeFSCache(files), options)
-        assert find_sources(finder, "/") == [
+        assert find_sources_in_dir(finder, "/") == [
             ("a2", "/pkg"),
             ("a2.b.c.d.e", "/pkg"),
             ("a2.b.f", "/pkg"),
@@ -212,7 +232,7 @@ def test_find_sources_namespace(self) -> None:
             ("f", "/pkg/a1/b"),
         ]
 
-    def test_find_sources_namespace_explicit_base(self) -> None:
+    def test_find_sources_in_dir_namespace_explicit_base(self) -> None:
         options = Options()
         options.namespace_packages = True
         options.explicit_package_bases = True
@@ -226,7 +246,7 @@ def test_find_sources_namespace_explicit_base(self) -> None:
             "/pkg/a2/b/f.py",
         }
         finder = SourceFinder(FakeFSCache(files), options)
-        assert find_sources(finder, "/") == [
+        assert find_sources_in_dir(finder, "/") == [
             ("pkg.a1.b.c.d.e", "/"),
             ("pkg.a1.b.f", "/"),
             ("pkg.a2", "/"),
@@ -236,7 +256,7 @@ def test_find_sources_namespace_explicit_base(self) -> None:
 
         options.mypy_path = ["/pkg"]
         finder = SourceFinder(FakeFSCache(files), options)
-        assert find_sources(finder, "/") == [
+        assert find_sources_in_dir(finder, "/") == [
             ("a1.b.c.d.e", "/pkg"),
             ("a1.b.f", "/pkg"),
             ("a2", "/pkg"),
@@ -244,11 +264,112 @@ def test_find_sources_namespace_explicit_base(self) -> None:
             ("a2.b.f", "/pkg"),
         ]
 
-    def test_find_sources_namespace_multi_dir(self) -> None:
+    def test_find_sources_in_dir_namespace_multi_dir(self) -> None:
         options = Options()
         options.namespace_packages = True
         options.explicit_package_bases = True
         options.mypy_path = ["/a", "/b"]
 
         finder = SourceFinder(FakeFSCache({"/a/pkg/a.py", "/b/pkg/b.py"}), options)
-        assert find_sources(finder, "/") == [("pkg.a", "/a"), ("pkg.b", "/b")]
+        assert find_sources_in_dir(finder, "/") == [("pkg.a", "/a"), ("pkg.b", "/b")]
+
+    def test_find_sources_exclude(self) -> None:
+        options = Options()
+        options.namespace_packages = True
+
+        # default
+        for excluded_dir in ["site-packages", ".whatever", "node_modules", ".x/.z"]:
+            fscache = FakeFSCache({"/dir/a.py", "/dir/venv/{}/b.py".format(excluded_dir)})
+            assert find_sources(["/"], options, fscache) == [("a", "/dir")]
+            with pytest.raises(InvalidSourceList):
+                find_sources(["/dir/venv/"], options, fscache)
+            assert find_sources(["/dir/venv/{}".format(excluded_dir)], options, fscache) == [
+                ("b", "/dir/venv/{}".format(excluded_dir))
+            ]
+            assert find_sources(["/dir/venv/{}/b.py".format(excluded_dir)], options, fscache) == [
+                ("b", "/dir/venv/{}".format(excluded_dir))
+            ]
+
+        files = {
+            "/pkg/a1/b/c/d/e.py",
+            "/pkg/a1/b/f.py",
+            "/pkg/a2/__init__.py",
+            "/pkg/a2/b/c/d/e.py",
+            "/pkg/a2/b/f.py",
+        }
+
+        # file name
+        options.exclude = r"/f\.py$"
+        fscache = FakeFSCache(files)
+        assert find_sources(["/"], options, fscache) == [
+            ("a2", "/pkg"),
+            ("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')]
+
+        # directory name
+        options.exclude = "/a1/"
+        fscache = FakeFSCache(files)
+        assert find_sources(["/"], options, fscache) == [
+            ("a2", "/pkg"),
+            ("a2.b.c.d.e", "/pkg"),
+            ("a2.b.f", "/pkg"),
+        ]
+        with pytest.raises(InvalidSourceList):
+            find_sources(["/pkg/a1"], options, fscache)
+        with pytest.raises(InvalidSourceList):
+            find_sources(["/pkg/a1/"], options, fscache)
+        with pytest.raises(InvalidSourceList):
+            find_sources(["/pkg/a1/b"], options, fscache)
+
+        options.exclude = "/a1/$"
+        assert find_sources(["/pkg/a1"], options, fscache) == [
+            ('e', '/pkg/a1/b/c/d'), ('f', '/pkg/a1/b')
+        ]
+
+        # paths
+        options.exclude = "/pkg/a1/"
+        fscache = FakeFSCache(files)
+        assert find_sources(["/"], options, fscache) == [
+            ("a2", "/pkg"),
+            ("a2.b.c.d.e", "/pkg"),
+            ("a2.b.f", "/pkg"),
+        ]
+        with pytest.raises(InvalidSourceList):
+            find_sources(["/pkg/a1"], options, fscache)
+
+        options.exclude = "/(a1|a3)/"
+        fscache = FakeFSCache(files)
+        assert find_sources(["/"], options, fscache) == [
+            ("a2", "/pkg"),
+            ("a2.b.c.d.e", "/pkg"),
+            ("a2.b.f", "/pkg"),
+        ]
+
+        options.exclude = "b/c/"
+        fscache = FakeFSCache(files)
+        assert find_sources(["/"], options, fscache) == [
+            ("a2", "/pkg"),
+            ("a2.b.f", "/pkg"),
+            ("f", "/pkg/a1/b"),
+        ]
+
+        # nothing should be ignored as a result of this
+        options.exclude = "|".join((
+            "/pkg/a/", "/2", "/1", "/pk/", "/kg", "/g.py", "/bc", "/xxx/pkg/a2/b/f.py"
+            "xxx/pkg/a2/b/f.py",
+        ))
+        fscache = FakeFSCache(files)
+        assert len(find_sources(["/"], options, fscache)) == len(files)
+
+        files = {
+            "pkg/a1/b/c/d/e.py",
+            "pkg/a1/b/f.py",
+            "pkg/a2/__init__.py",
+            "pkg/a2/b/c/d/e.py",
+            "pkg/a2/b/f.py",
+        }
+        fscache = FakeFSCache(files)
+        assert len(find_sources(["."], options, fscache)) == len(files)
diff --git a/mypy/version.py b/mypy/version.py
index 519cd53f74c3..2e869f8a511e 100644
--- a/mypy/version.py
+++ b/mypy/version.py
@@ -5,7 +5,7 @@
 # - Release versions have the form "0.NNN".
 # - Dev versions have the form "0.NNN+dev" (PLUS sign to conform to PEP 440).
 # - For 1.0 we'll switch back to 1.2.3 form.
-__version__ = '0.800'
+__version__ = '0.812'
 base_version = __version__
 
 mypy_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
diff --git a/mypy_self_check.ini b/mypy_self_check.ini
index 2b7ed2b157c5..c974a0248afc 100644
--- a/mypy_self_check.ini
+++ b/mypy_self_check.ini
@@ -19,3 +19,4 @@ pretty = True
 always_false = MYPYC
 plugins = misc/proper_plugin.py
 python_version = 3.5
+exclude = /mypy/typeshed/
diff --git a/test-data/unit/cmdline.test b/test-data/unit/cmdline.test
index 8fe9f478a077..4c78928500b0 100644
--- a/test-data/unit/cmdline.test
+++ b/test-data/unit/cmdline.test
@@ -59,7 +59,7 @@ undef
 undef
 [out]
 dir/a.py: error: Duplicate module named 'a' (also at 'dir/subdir/a.py')
-dir/a.py: error: Are you missing an __init__.py?
+dir/a.py: note: Are you missing an __init__.py? Alternatively, consider using --exclude to avoid checking one of them.
 == Return code: 2
 
 [case testCmdlineNonPackageSlash]
@@ -125,19 +125,7 @@ mypy: can't decode file 'a.py': unknown encoding: uft-8
 # type: ignore
 [out]
 two/mod/__init__.py: error: Duplicate module named 'mod' (also at 'one/mod/__init__.py')
-== Return code: 2
-
-[case promptsForgotInit]
-# cmd: mypy a.py one/mod/a.py
-[file one/__init__.py]
-# type: ignore
-[file a.py]
-# type: ignore
-[file one/mod/a.py]
-#type: ignore
-[out]
-one/mod/a.py: error: Duplicate module named 'a' (also at 'a.py')
-one/mod/a.py: error: Are you missing an __init__.py?
+two/mod/__init__.py: note: Are you missing an __init__.py? Alternatively, consider using --exclude to avoid checking one of them.
 == Return code: 2
 
 [case testFlagsFile]

<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html xmlns='http://www.w3.org/1999/xhtml'>
<head>
<title>pFad - Phonifier reborn</title>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />
</head>
<body>
<h1>Pfad - The Proxy pFad of &#169; 2024 Garber Painting. All rights reserved.</h1>


<!-- Disclaimer -->
<p>Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.</p>
<br>
<p>Alternative Proxies:</p><p><a href="http://rainy.clevelandohioweatherforecast.com/php-proxy/index.php?q=https://github.com/python/mypy/compare/v0.800...v0.812.diff" target="_blank">Alternative Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/index.php?u=https://github.com/python/mypy/compare/v0.800...v0.812.diff" target="_blank">pFad Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v3index.php?u=https://github.com/python/mypy/compare/v0.800...v0.812.diff" target="_blank">pFad v3 Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v4index.php?u=https://github.com/python/mypy/compare/v0.800...v0.812.diff" target="_blank">pFad v4 Proxy</a></p></body>
</html>