text: # coding: utf-8
  #
  # Copyright 2011 Yesudeep Mangalapilly <yesudeep@gmail.com>
  # Copyright 2012 Google, Inc & contributors.
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  #     http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  
  
  """
  :module: watchdog.observers.polling
  :synopsis: Polling emitter implementation.
  :author: yesudeep@google.com (Yesudeep Mangalapilly)
  :author: contact@tiger-222.fr (Mickaël Schoentgen)
  
  Classes
  -------
  .. autoclass:: PollingObserver
     :members:
     :show-inheritance:
  
  .. autoclass:: PollingObserverVFS
     :members:
     :show-inheritance:
     :special-members:
  """
  
  import os
  import threading
  from functools import partial
  
  from reloadium.vendored.watchdog.utils.dirsnapshot import DirectorySnapshot, DirectorySnapshotDiff
  from reloadium.vendored.watchdog.observers.api import EventEmitter, BaseObserver, DEFAULT_OBSERVER_TIMEOUT, DEFAULT_EMITTER_TIMEOUT
  
  from reloadium.vendored.watchdog.events import (
      DirMovedEvent,
      DirDeletedEvent,
      DirCreatedEvent,
      DirModifiedEvent,
      FileMovedEvent,
      FileDeletedEvent,
      FileCreatedEvent,
      FileModifiedEvent,
  )
  
  
  class PollingEmitter(EventEmitter):
      """
      Platform-independent emitter that polls a directory to detect file
      system changes.
      """
  
      def __init__(self, event_queue, watch, timeout=DEFAULT_EMITTER_TIMEOUT, stat=os.stat, listdir=os.scandir):
          EventEmitter.__init__(self, event_queue, watch, timeout)
          self._snapshot = None
          self._lock = threading.Lock()
          self._take_snapshot = lambda: DirectorySnapshot(
              self.watch.path, self.watch.is_recursive, stat=stat, listdir=listdir
          )
  
      def on_thread_start(self):
          self._snapshot = self._take_snapshot()
  
      def queue_events(self, timeout):
          # We don't want to hit the disk continuously.
          # timeout behaves like an interval for polling emitters.
          if self.stopped_event.wait(timeout):
              return
  
          with self._lock:
              if not self.should_keep_running():
                  return
  
              # Get event diff between fresh snapshot and previous snapshot.
              # Update snapshot.
              try:
                  new_snapshot = self._take_snapshot()
              except OSError:
                  self.queue_event(DirDeletedEvent(self.watch.path))
                  self.stop()
                  return
  
              events = DirectorySnapshotDiff(self._snapshot, new_snapshot)
              self._snapshot = new_snapshot
  
              # Files.
              for src_path in events.files_deleted:
                  self.queue_event(FileDeletedEvent(src_path))
              for src_path in events.files_modified:
                  self.queue_event(FileModifiedEvent(src_path))
              for src_path in events.files_created:
                  self.queue_event(FileCreatedEvent(src_path))
              for src_path, dest_path in events.files_moved:
                  self.queue_event(FileMovedEvent(src_path, dest_path))
  
              # Directories.
              for src_path in events.dirs_deleted:
                  self.queue_event(DirDeletedEvent(src_path))
              for src_path in events.dirs_modified:
                  self.queue_event(DirModifiedEvent(src_path))
              for src_path in events.dirs_created:
                  self.queue_event(DirCreatedEvent(src_path))
              for src_path, dest_path in events.dirs_moved:
                  self.queue_event(DirMovedEvent(src_path, dest_path))
  
  
  class PollingObserver(BaseObserver):
      """
      Platform-independent observer that polls a directory to detect file
      system changes.
      """
  
      def __init__(self, timeout=DEFAULT_OBSERVER_TIMEOUT):
          BaseObserver.__init__(self, emitter_class=PollingEmitter, timeout=timeout)
  
  
  class PollingObserverVFS(BaseObserver):
      """
      File system independent observer that polls a directory to detect changes.
      """
  
      def __init__(self, stat, listdir, polling_interval=1):
          """
          :param stat: stat function. See ``os.stat`` for details.
          :param listdir: listdir function. See ``os.scandir`` for details.
          :type polling_interval: float
          :param polling_interval: interval in seconds between polling the file system.
          """
          emitter_cls = partial(PollingEmitter, stat=stat, listdir=listdir)
          BaseObserver.__init__(self, emitter_class=emitter_cls, timeout=polling_interval)
  