if an error is raised while importing a file it s not placed in sys modules this means that any future modifications aren t caught keep a list of these file paths to allow watching them in the future return true if the given module is nested under django return module name startswithdjango def isdjangopathpath get the filename from the last item in the stack ensure that echo mode is enabled some tools such as pdb disable it which causes usability issues after reload this is a hot path during reloading create a stable sorted list of modules based on the module name and pass it to itermodulesandfiles this ensures cached results are returned in the usual case that modules aren t loaded on the fly iterate through all modules needed to be watched sysfilepaths for module in modules during debugging with pydev the typing io and typing re objects are added to sys modules however they are types not modules and so cause issues here if not isinstancemodule moduletype continue if module name in main mpmain main usually manage py doesn t always have a spec set handle this by falling back to using file resolved below see https docs python orgreferenceimport htmlmainspec file may not exists e g when running ipdb debugger if hasattrmodule file sysfilepaths appendmodule file continue if getattrmodule spec none is none continue spec module spec modules could be loaded from places without a concrete location if this is the case skip them if spec haslocation origin spec loader archive if isinstancespec loader zipimporter else spec origin sysfilepaths appendorigin results set for filename in itertools chainsysfilepaths extrafiles if not filename continue path pathfilename try if not path exists the module could have been removed don t fail loudly if this is the case continue except valueerror as e network filesystems may return null bytes in file paths logger debug s raised when resolving path s e path continue resolvedpath path resolve absolute results addresolvedpath return frozensetresults lrucachemaxsize1 def commonrootspaths inspired from werkzeug https github compalletswerkzeugblob7477be2853df70a022d9613e765581b9411c3c39werkzeugreloader py create a sorted list of the path components longest first pathparts sortedx parts for x in paths keylen reversetrue tree for chunks in pathparts node tree add each part of the path to the tree for chunk in chunks node node setdefaultchunk clear the last leaf in the tree node clear turn the tree into a list of path instances def walknode path for prefix child in node items yield from walkchild path prefix if not node yield pathpath return tuplewalktree def syspathdirectories for path in sys path path pathpath if not path exists continue resolvedpath path resolve absolute if the path is a file like a zip file watch the parent directory if resolvedpath isfile yield resolvedpath parent else yield resolvedpath def getchildarguments import main pyscript pathsys argv0 exeentrypoint pyscript withsuffix exe args sys executable ws o for o in sys warnoptions if sys implementation name in cpython pypy args extend fxkey if value is true else fxkeyvalue for key value in sys xoptions items spec is set when the server was started with the m option see https docs python org3referenceimport htmlmainspec spec may not exist e g when running in a conda env if getattrmain spec none is not none and not exeentrypoint exists spec main spec if spec name main or spec name endswith main and spec parent name spec parent else name spec name args m name args sys argv1 elif not pyscript exists sys argv0 may not exist for several reasons on windows it may exist with a exe extension or have a script py suffix if exeentrypoint exists should be executed directly ignoring sys executable return exeentrypoint sys argv1 scriptentrypoint pyscript withnamesscript py pyscript name if scriptentrypoint exists should be executed as usual return args scriptentrypoint sys argv1 raise runtimeerrorscript s does not exist pyscript else args sys argv return args def triggerreloadfilename logger infos changed reloading filename sys exit3 def restartwithreloader newenviron os environ djangoautoreloadenv true args getchildarguments while true p subprocess runargs envnewenviron closefdsfalse if p returncode 3 return p returncode class basereloader def initself self extrafiles set self directoryglobs defaultdictset self stopcondition threading event def watchdirself path glob path pathpath try path path absolute except filenotfounderror logger debug unable to watch directory s as it cannot be resolved path excinfotrue return logger debugwatching dir s with glob s path glob self directoryglobspath addglob def watchedfilesself includeglobstrue yield from iterallpythonmodulefiles yield from self extrafiles if includeglobs for directory patterns in self directoryglobs items for pattern in patterns yield from directory globpattern def waitforappsreadyself appreg djangomainthread while djangomainthread isalive if appreg readyevent waittimeout0 1 return true else logger debugmain django thread has terminated before apps are ready return false def runself djangomainthread logger debugwaiting for apps readyevent self waitforappsreadyapps djangomainthread from django urls import getresolver prevent a race condition where url modules aren t loaded when the reloader starts by accessing the urlconfmodule property try getresolver urlconfmodule except exception loading the urlconf can result in errors during development if this occurs then swallow the error and continue pass logger debugapps readyevent triggered sending autoreloadstarted signal autoreloadstarted sendsenderself self runloop def runloopself ticker self tick while not self shouldstop try nextticker except stopiteration break self stop def tickself raise notimplementederrorsubclasses must implement tick classmethod def checkavailabilitycls raise notimplementederrorsubclasses must implement checkavailability def notifyfilechangedself path results filechanged sendsenderself filepathpath logger debugs notified as changed signal results s path results if not anyres1 for res in results triggerreloadpath these are primarily used for testing property def shouldstopself return self stopcondition isset def stopself self stopcondition set class statreloaderbasereloader sleeptime 1 check for changes once per second def tickself mtimes while true for filepath mtime in self snapshotfiles oldtime mtimes getfilepath mtimesfilepath mtime if oldtime is none logger debugfile s first seen with mtime s filepath mtime continue elif mtime oldtime logger debug file s previous mtime s current mtime s filepath oldtime mtime self notifyfilechangedfilepath time sleepself sleeptime yield def snapshotfilesself watchedfiles may produce duplicate paths if globs overlap seenfiles set for file in self watchedfiles if file in seenfiles continue try mtime file stat stmtime except oserror this is thrown when the file does not exist continue seenfiles addfile yield file mtime classmethod def checkavailabilitycls return true class watchmanunavailableruntimeerror pass class watchmanreloaderbasereloader def initself self roots defaultdictset self processedrequest threading event self clienttimeout intos environ getdjangowatchmantimeout 5 super init cachedproperty def clientself return pywatchman clienttimeoutself clienttimeout def watchrootself root in practice this shouldn t occur however it s possible that a directory that doesn t exist yet is being watched if it s outside of sys path then this will end up a new root how to handle this isn t clear not adding the root will likely break when subscribing to the changes however as this is currently an internal api no files will be being watched outside of sys path fixing this by checking inside watchglob and watchdir is expensive instead this could could fall back to the statreloader if this case is detected for now watching its parent if possible is sufficient if not root exists if not root parent exists logger warning unable to watch root dir s as neither it or its parent exist root return root root parent result self client querywatchproject strroot absolute if warning in result logger warningwatchman warning s resultwarning logger debugwatchman watchproject result s result return resultwatch result getrelativepath lrucache def getclockself root return self client queryclock rootclock def subscribeself directory name expression root relpath self watchrootdirectory only receive notifications of files changing filtering out other types like special files https facebook github iowatchmandocstype onlyfilesexpression allof anyof type f type l expression query expression onlyfilesexpression fields name since self getclockroot dedupresults true if relpath queryrelativeroot relpath logger debug issuing watchman subscription s for root s query s name root query self client querysubscribe root name query def subscribedirself directory filenames if not directory exists if not directory parent exists logger warning unable to watch directory s as neither it or its parent exist directory return prefix filesparents directory name filenames ss directory name filename for filename in filenames directory directory parent expression name filenames wholename else prefix files expression name filenames self subscribedirectory s s prefix directory expression def watchglobself directory patterns prefix glob if not directory exists if not directory parent exists logger warning unable to watch directory s as neither it or its parent exist directory return prefix globparents directory name patterns ss directory name pattern for pattern in patterns directory directory parent expression anyof for pattern in patterns expression appendmatch pattern wholename self subscribedirectory s s prefix directory expression def watchedrootsself watchedfiles extradirectories self directoryglobs keys watchedfiledirs f parent for f in watchedfiles syspaths listsyspathdirectories return frozensetextradirectories watchedfiledirs syspaths def updatewatchesself watchedfiles listself watchedfilesincludeglobsfalse foundroots commonrootsself watchedrootswatchedfiles logger debugwatching s files lenwatchedfiles logger debugfound common roots s foundroots setup initial roots for performance shortest roots first for root in sortedfoundroots self watchrootroot for directory patterns in self directoryglobs items self watchglobdirectory patterns group sorted watchedfiles by their parent directory sortedfiles sortedwatchedfiles keylambda p p parent for directory group in itertools groupbysortedfiles keylambda p p parent these paths need to be relative to the parent directory self subscribedir directory strp relativetodirectory for p in group def updatewatchesself try self updatewatches except exception as ex if the service is still available raise the original exception if self checkserverstatusex raise def checksubscriptionself sub subscription self client getsubscriptionsub if not subscription return logger debugwatchman subscription s has results sub for result in subscription when using watchproject it s not simple to get the relative directory without storing some specific state store the full path to the directory in the subscription name prefixed by its type glob files rootdirectory pathresultsubscription split 11 logger debugfound root directory s rootdirectory for file in result getfiles self notifyfilechangedrootdirectory file def requestprocessedself kwargs logger debugrequest processed setting updatewatches event self processedrequest set def tickself requestfinished connectself requestprocessed self updatewatches while true if self processedrequest isset self updatewatches self processedrequest clear try self client receive except pywatchman sockettimeout pass except pywatchman watchmanerror as ex logger debugwatchman error s checking server status ex self checkserverstatusex else for sub in listself client subs keys self checksubscriptionsub yield protect against busy loops time sleep0 1 def stopself self client close super stop def checkserverstatusself innerexnone the service is down watchman 4 9 includes multiple improvements to watching project directories as well as case insensitive filesystems return the most suitable reloader for this environment try watchmanreloader checkavailability except watchmanunavailable return statreloader return watchmanreloader def startdjangoreloader mainfunc args kwargs ensureechoon mainfunc checkerrorsmainfunc djangomainthread threading thread targetmainfunc argsargs kwargskwargs namedjangomainthread djangomainthread daemon true djangomainthread start while not reloader shouldstop reloader rundjangomainthread def runwithreloadermainfunc args kwargs signal signalsignal sigterm lambda args sys exit0 try if os environ getdjangoautoreloadenv true reloader getreloader logger info watching for file changes with s reloader class name startdjangoreloader mainfunc args kwargs else exitcode restartwithreloader sys exitexitcode except keyboardinterrupt pass if an error is raised while importing a file it s not placed in sys modules this means that any future modifications aren t caught keep a list of these file paths to allow watching them in the future return true if the given module is nested under django return true if the given file path is nested under django get the filename from the last item in the stack ensure that echo mode is enabled some tools such as pdb disable it which causes usability issues after reload this is a hot path during reloading create a stable sorted list of modules based on the module name and pass it to iter_modules_and_files this ensures cached results are returned in the usual case that modules aren t loaded on the fly iterate through all modules needed to be watched during debugging with pydev the typing io and typing re objects are added to sys modules however they are types not modules and so cause issues here __main__ usually manage py doesn t always have a __spec__ set handle this by falling back to using __file__ resolved below see https docs python org reference import html main spec __file__ may not exists e g when running ipdb debugger modules could be loaded from places without a concrete location if this is the case skip them the module could have been removed don t fail loudly if this is the case network filesystems may return null bytes in file paths return a tuple of common roots that are shared between the given paths file system watchers operate on directories and aren t cheap to create try to find the minimum set of directories to watch that encompass all of the files that need to be watched inspired from werkzeug https github com pallets werkzeug blob 7477be2853df70a022d9613e765581b9411c3c39 werkzeug _reloader py create a sorted list of the path components longest first add each part of the path to the tree clear the last leaf in the tree turn the tree into a list of path instances yield absolute directories from sys path ignoring entries that don t exist if the path is a file like a zip file watch the parent directory return the executable this contains a workaround for windows if the executable is reported to not have the exe extension which can cause bugs on reloading __spec__ is set when the server was started with the m option see https docs python org 3 reference import html main spec __spec__ may not exist e g when running in a conda env sys argv 0 may not exist for several reasons on windows it may exist with a exe extension or have a script py suffix should be executed directly ignoring sys executable should be executed as usual yield all files that need to be watched including module files and files within globs wait until django reports that the apps have been loaded if the given thread has terminated before the apps are ready then a syntaxerror or other non recoverable error has been raised in that case stop waiting for the apps_ready event and continue processing return true if the thread is alive and the ready event has been triggered or false if the thread is terminated while waiting for the event prevent a race condition where url modules aren t loaded when the reloader starts by accessing the urlconf_module property loading the urlconf can result in errors during development if this occurs then swallow the error and continue this generator is called in a loop from run_loop it s important that the method takes care of pausing or otherwise waiting for a period of time this split between run_loop and tick is to improve the testability of the reloader implementations by decoupling the work they do from the loop these are primarily used for testing check for changes once per second watched_files may produce duplicate paths if globs overlap this is thrown when the file does not exist in practice this shouldn t occur however it s possible that a directory that doesn t exist yet is being watched if it s outside of sys path then this will end up a new root how to handle this isn t clear not adding the root will likely break when subscribing to the changes however as this is currently an internal api no files will be being watched outside of sys path fixing this by checking inside watch_glob and watch_dir is expensive instead this could could fall back to the statreloader if this case is detected for now watching its parent if possible is sufficient only receive notifications of files changing filtering out other types like special files https facebook github io watchman docs type watch a directory with a specific glob if the directory doesn t yet exist attempt to watch the parent directory and amend the patterns to include this it s important this method isn t called more than one per directory when updating all subscriptions subsequent calls will overwrite the named subscription so it must include all possible glob expressions setup initial roots for performance shortest roots first group sorted watched_files by their parent directory these paths need to be relative to the parent directory if the service is still available raise the original exception when using watch project it s not simple to get the relative directory without storing some specific state store the full path to the directory in the subscription name prefixed by its type glob files protect against busy loops return true if the server is available the service is down watchman 4 9 includes multiple improvements to watching project directories as well as case insensitive filesystems return the most suitable reloader for this environment
import itertools
import logging
import os
import signal
import subprocess
import sys
import threading
import time
import traceback
import weakref
from collections import defaultdict
from functools import lru_cache, wraps
from pathlib import Path
from types import ModuleType
from zipimport import zipimporter

import django
from django.apps import apps
from django.core.signals import request_finished
from django.dispatch import Signal
from django.utils.functional import cached_property
from django.utils.version import get_version_tuple

autoreload_started = Signal()
file_changed = Signal()

DJANGO_AUTORELOAD_ENV = "RUN_MAIN"

logger = logging.getLogger("django.utils.autoreload")




_error_files = []
_exception = None

try:
    import termios
except ImportError:
    termios = None


try:
    import pywatchman
except ImportError:
    pywatchman = None


def is_django_module(module):
    
    return module.__name__.startswith("django.")


def is_django_path(path):
    
    return Path(django.__file__).parent in Path(path).parents


def check_errors(fn):
    @wraps(fn)
    def wrapper(*args, **kwargs):
        global _exception
        try:
            fn(*args, **kwargs)
        except Exception:
            _exception = sys.exc_info()

            et, ev, tb = _exception

            if getattr(ev, "filename", None) is None:
                
                filename = traceback.extract_tb(tb)[-1][0]
            else:
                filename = ev.filename

            if filename not in _error_files:
                _error_files.append(filename)

            raise

    return wrapper


def raise_last_exception():
    global _exception
    if _exception is not None:
        raise _exception[1]


def ensure_echo_on():
    
    if not termios or not sys.stdin.isatty():
        return
    attr_list = termios.tcgetattr(sys.stdin)
    if not attr_list[3] & termios.ECHO:
        attr_list[3] |= termios.ECHO
        if hasattr(signal, "SIGTTOU"):
            old_handler = signal.signal(signal.SIGTTOU, signal.SIG_IGN)
        else:
            old_handler = None
        termios.tcsetattr(sys.stdin, termios.TCSANOW, attr_list)
        if old_handler is not None:
            signal.signal(signal.SIGTTOU, old_handler)


def iter_all_python_module_files():
    
    
    
    
    keys = sorted(sys.modules)
    modules = tuple(
        m
        for m in map(sys.modules.__getitem__, keys)
        if not isinstance(m, weakref.ProxyTypes)
    )
    return iter_modules_and_files(modules, frozenset(_error_files))


@lru_cache(maxsize=1)
def iter_modules_and_files(modules, extra_files):
    
    sys_file_paths = []
    for module in modules:
        
        
        
        if not isinstance(module, ModuleType):
            continue
        if module.__name__ in ("__main__", "__mp_main__"):
            
            
            
            
            if hasattr(module, "__file__"):
                sys_file_paths.append(module.__file__)
            continue
        if getattr(module, "__spec__", None) is None:
            continue
        spec = module.__spec__
        
        
        if spec.has_location:
            origin = (
                spec.loader.archive
                if isinstance(spec.loader, zipimporter)
                else spec.origin
            )
            sys_file_paths.append(origin)

    results = set()
    for filename in itertools.chain(sys_file_paths, extra_files):
        if not filename:
            continue
        path = Path(filename)
        try:
            if not path.exists():
                
                
                continue
        except ValueError as e:
            
            logger.debug('"%s" raised when resolving path: "%s"', e, path)
            continue
        resolved_path = path.resolve().absolute()
        results.add(resolved_path)
    return frozenset(results)


@lru_cache(maxsize=1)
def common_roots(paths):
    
    
    
    
    path_parts = sorted([x.parts for x in paths], key=len, reverse=True)
    tree = {}
    for chunks in path_parts:
        node = tree
        
        for chunk in chunks:
            node = node.setdefault(chunk, {})
        
        node.clear()

    
    def _walk(node, path):
        for prefix, child in node.items():
            yield from _walk(child, path + (prefix,))
        if not node:
            yield Path(*path)

    return tuple(_walk(tree, ()))


def sys_path_directories():
    
    for path in sys.path:
        path = Path(path)
        if not path.exists():
            continue
        resolved_path = path.resolve().absolute()
        
        if resolved_path.is_file():
            yield resolved_path.parent
        else:
            yield resolved_path


def get_child_arguments():
    
    import __main__

    py_script = Path(sys.argv[0])
    exe_entrypoint = py_script.with_suffix(".exe")

    args = [sys.executable] + ["-W%s" % o for o in sys.warnoptions]
    if sys.implementation.name in ("cpython", "pypy"):
        args.extend(
            f"-X{key}" if value is True else f"-X{key}={value}"
            for key, value in sys._xoptions.items()
        )
    
    
    
    if getattr(__main__, "__spec__", None) is not None and not exe_entrypoint.exists():
        spec = __main__.__spec__
        if (spec.name == "__main__" or spec.name.endswith(".__main__")) and spec.parent:
            name = spec.parent
        else:
            name = spec.name
        args += ["-m", name]
        args += sys.argv[1:]
    elif not py_script.exists():
        
        
        if exe_entrypoint.exists():
            
            return [exe_entrypoint, *sys.argv[1:]]
        script_entrypoint = py_script.with_name("%s-script.py" % py_script.name)
        if script_entrypoint.exists():
            
            return [*args, script_entrypoint, *sys.argv[1:]]
        raise RuntimeError("Script %s does not exist." % py_script)
    else:
        args += sys.argv
    return args


def trigger_reload(filename):
    logger.info("%s changed, reloading.", filename)
    sys.exit(3)


def restart_with_reloader():
    new_environ = {**os.environ, DJANGO_AUTORELOAD_ENV: "true"}
    args = get_child_arguments()
    while True:
        p = subprocess.run(args, env=new_environ, close_fds=False)
        if p.returncode != 3:
            return p.returncode


class BaseReloader:
    def __init__(self):
        self.extra_files = set()
        self.directory_globs = defaultdict(set)
        self._stop_condition = threading.Event()

    def watch_dir(self, path, glob):
        path = Path(path)
        try:
            path = path.absolute()
        except FileNotFoundError:
            logger.debug(
                "Unable to watch directory %s as it cannot be resolved.",
                path,
                exc_info=True,
            )
            return
        logger.debug("Watching dir %s with glob %s.", path, glob)
        self.directory_globs[path].add(glob)

    def watched_files(self, include_globs=True):
        
        yield from iter_all_python_module_files()
        yield from self.extra_files
        if include_globs:
            for directory, patterns in self.directory_globs.items():
                for pattern in patterns:
                    yield from directory.glob(pattern)

    def wait_for_apps_ready(self, app_reg, django_main_thread):
        
        while django_main_thread.is_alive():
            if app_reg.ready_event.wait(timeout=0.1):
                return True
        else:
            logger.debug("Main Django thread has terminated before apps are ready.")
            return False

    def run(self, django_main_thread):
        logger.debug("Waiting for apps ready_event.")
        self.wait_for_apps_ready(apps, django_main_thread)
        from django.urls import get_resolver

        
        
        try:
            get_resolver().urlconf_module
        except Exception:
            
            
            pass
        logger.debug("Apps ready_event triggered. Sending autoreload_started signal.")
        autoreload_started.send(sender=self)
        self.run_loop()

    def run_loop(self):
        ticker = self.tick()
        while not self.should_stop:
            try:
                next(ticker)
            except StopIteration:
                break
        self.stop()

    def tick(self):
        
        raise NotImplementedError("subclasses must implement tick().")

    @classmethod
    def check_availability(cls):
        raise NotImplementedError("subclasses must implement check_availability().")

    def notify_file_changed(self, path):
        results = file_changed.send(sender=self, file_path=path)
        logger.debug("%s notified as changed. Signal results: %s.", path, results)
        if not any(res[1] for res in results):
            trigger_reload(path)

    
    @property
    def should_stop(self):
        return self._stop_condition.is_set()

    def stop(self):
        self._stop_condition.set()


class StatReloader(BaseReloader):
    SLEEP_TIME = 1  

    def tick(self):
        mtimes = {}
        while True:
            for filepath, mtime in self.snapshot_files():
                old_time = mtimes.get(filepath)
                mtimes[filepath] = mtime
                if old_time is None:
                    logger.debug("File %s first seen with mtime %s", filepath, mtime)
                    continue
                elif mtime > old_time:
                    logger.debug(
                        "File %s previous mtime: %s, current mtime: %s",
                        filepath,
                        old_time,
                        mtime,
                    )
                    self.notify_file_changed(filepath)

            time.sleep(self.SLEEP_TIME)
            yield

    def snapshot_files(self):
        
        seen_files = set()
        for file in self.watched_files():
            if file in seen_files:
                continue
            try:
                mtime = file.stat().st_mtime
            except OSError:
                
                continue
            seen_files.add(file)
            yield file, mtime

    @classmethod
    def check_availability(cls):
        return True


class WatchmanUnavailable(RuntimeError):
    pass


class WatchmanReloader(BaseReloader):
    def __init__(self):
        self.roots = defaultdict(set)
        self.processed_request = threading.Event()
        self.client_timeout = int(os.environ.get("DJANGO_WATCHMAN_TIMEOUT", 5))
        super().__init__()

    @cached_property
    def client(self):
        return pywatchman.client(timeout=self.client_timeout)

    def _watch_root(self, root):
        
        
        
        
        
        
        
        
        
        if not root.exists():
            if not root.parent.exists():
                logger.warning(
                    "Unable to watch root dir %s as neither it or its parent exist.",
                    root,
                )
                return
            root = root.parent
        result = self.client.query("watch-project", str(root.absolute()))
        if "warning" in result:
            logger.warning("Watchman warning: %s", result["warning"])
        logger.debug("Watchman watch-project result: %s", result)
        return result["watch"], result.get("relative_path")

    @lru_cache
    def _get_clock(self, root):
        return self.client.query("clock", root)["clock"]

    def _subscribe(self, directory, name, expression):
        root, rel_path = self._watch_root(directory)
        
        
        only_files_expression = [
            "allof",
            ["anyof", ["type", "f"], ["type", "l"]],
            expression,
        ]
        query = {
            "expression": only_files_expression,
            "fields": ["name"],
            "since": self._get_clock(root),
            "dedup_results": True,
        }
        if rel_path:
            query["relative_root"] = rel_path
        logger.debug(
            "Issuing watchman subscription %s, for root %s. Query: %s",
            name,
            root,
            query,
        )
        self.client.query("subscribe", root, name, query)

    def _subscribe_dir(self, directory, filenames):
        if not directory.exists():
            if not directory.parent.exists():
                logger.warning(
                    "Unable to watch directory %s as neither it or its parent exist.",
                    directory,
                )
                return
            prefix = "files-parent-%s" % directory.name
            filenames = ["%s/%s" % (directory.name, filename) for filename in filenames]
            directory = directory.parent
            expression = ["name", filenames, "wholename"]
        else:
            prefix = "files"
            expression = ["name", filenames]
        self._subscribe(directory, "%s:%s" % (prefix, directory), expression)

    def _watch_glob(self, directory, patterns):
        
        prefix = "glob"
        if not directory.exists():
            if not directory.parent.exists():
                logger.warning(
                    "Unable to watch directory %s as neither it or its parent exist.",
                    directory,
                )
                return
            prefix = "glob-parent-%s" % directory.name
            patterns = ["%s/%s" % (directory.name, pattern) for pattern in patterns]
            directory = directory.parent

        expression = ["anyof"]
        for pattern in patterns:
            expression.append(["match", pattern, "wholename"])
        self._subscribe(directory, "%s:%s" % (prefix, directory), expression)

    def watched_roots(self, watched_files):
        extra_directories = self.directory_globs.keys()
        watched_file_dirs = [f.parent for f in watched_files]
        sys_paths = list(sys_path_directories())
        return frozenset((*extra_directories, *watched_file_dirs, *sys_paths))

    def _update_watches(self):
        watched_files = list(self.watched_files(include_globs=False))
        found_roots = common_roots(self.watched_roots(watched_files))
        logger.debug("Watching %s files", len(watched_files))
        logger.debug("Found common roots: %s", found_roots)
        
        for root in sorted(found_roots):
            self._watch_root(root)
        for directory, patterns in self.directory_globs.items():
            self._watch_glob(directory, patterns)
        
        sorted_files = sorted(watched_files, key=lambda p: p.parent)
        for directory, group in itertools.groupby(sorted_files, key=lambda p: p.parent):
            
            self._subscribe_dir(
                directory, [str(p.relative_to(directory)) for p in group]
            )

    def update_watches(self):
        try:
            self._update_watches()
        except Exception as ex:
            
            if self.check_server_status(ex):
                raise

    def _check_subscription(self, sub):
        subscription = self.client.getSubscription(sub)
        if not subscription:
            return
        logger.debug("Watchman subscription %s has results.", sub)
        for result in subscription:
            
            
            
            
            root_directory = Path(result["subscription"].split(":", 1)[1])
            logger.debug("Found root directory %s", root_directory)
            for file in result.get("files", []):
                self.notify_file_changed(root_directory / file)

    def request_processed(self, **kwargs):
        logger.debug("Request processed. Setting update_watches event.")
        self.processed_request.set()

    def tick(self):
        request_finished.connect(self.request_processed)
        self.update_watches()
        while True:
            if self.processed_request.is_set():
                self.update_watches()
                self.processed_request.clear()
            try:
                self.client.receive()
            except pywatchman.SocketTimeout:
                pass
            except pywatchman.WatchmanError as ex:
                logger.debug("Watchman error: %s, checking server status.", ex)
                self.check_server_status(ex)
            else:
                for sub in list(self.client.subs.keys()):
                    self._check_subscription(sub)
            yield
            
            time.sleep(0.1)

    def stop(self):
        self.client.close()
        super().stop()

    def check_server_status(self, inner_ex=None):
        
        try:
            self.client.query("version")
        except Exception:
            raise WatchmanUnavailable(str(inner_ex)) from inner_ex
        return True

    @classmethod
    def check_availability(cls):
        if not pywatchman:
            raise WatchmanUnavailable("pywatchman not installed.")
        client = pywatchman.client(timeout=0.1)
        try:
            result = client.capabilityCheck()
        except Exception:
            
            raise WatchmanUnavailable("Cannot connect to the watchman service.")
        version = get_version_tuple(result["version"])
        
        
        logger.debug("Watchman version %s", version)
        if version < (4, 9):
            raise WatchmanUnavailable("Watchman 4.9 or later is required.")


def get_reloader():
    
    try:
        WatchmanReloader.check_availability()
    except WatchmanUnavailable:
        return StatReloader()
    return WatchmanReloader()


def start_django(reloader, main_func, *args, **kwargs):
    ensure_echo_on()

    main_func = check_errors(main_func)
    django_main_thread = threading.Thread(
        target=main_func, args=args, kwargs=kwargs, name="django-main-thread"
    )
    django_main_thread.daemon = True
    django_main_thread.start()

    while not reloader.should_stop:
        reloader.run(django_main_thread)


def run_with_reloader(main_func, *args, **kwargs):
    signal.signal(signal.SIGTERM, lambda *args: sys.exit(0))
    try:
        if os.environ.get(DJANGO_AUTORELOAD_ENV) == "true":
            reloader = get_reloader()
            logger.info(
                "Watching for file changes with %s", reloader.__class__.__name__
            )
            start_django(reloader, main_func, *args, **kwargs)
        else:
            exit_code = restart_with_reloader()
            sys.exit(exit_code)
    except KeyboardInterrupt:
        pass