def dispatch(self, event):
    """Dispatches events to the appropriate methods.

    :param event:
        The event object representing the file system event.
    :type event:
        :class:`FileSystemEvent`
    """
    if self.ignore_directories and event.is_directory:
      return

    if has_attribute(event, 'src_path') and has_attribute(event, 'dest_path'):
      paths = [event.src_path, event.dest_path]
    elif has_attribute(event, 'src_path'):
      paths = [event.src_path]
    elif has_attribute(event, 'dest_path'):
      paths = [event.dest_path]
    else:
      paths = []

    if match_any_paths(paths,
                       included_patterns=self.patterns,
                       excluded_patterns=self.ignore_patterns,
                       case_sensitive=self.case_sensitive):
      self.on_any_event(event)
      _method_map = {
        EVENT_TYPE_MODIFIED: self.on_modified,
        EVENT_TYPE_MOVED: self.on_moved,
        EVENT_TYPE_CREATED: self.on_created,
        EVENT_TYPE_DELETED: self.on_deleted,
        }
      event_type = event.event_type
      _method_map[event_type](event)

    def on_any_event(self, event):
        from string import Template

        if self.drop_during_process and self.process and self.process.poll() is None:
            return

        if event.is_directory:
            object_type = 'directory'
        else:
            object_type = 'file'

        context = {
            'watch_src_path': event.src_path,
            'watch_dest_path': '',
            'watch_event_type': event.event_type,
            'watch_object': object_type,
        }

        if self.shell_command is None:
            if has_attribute(event, 'dest_path'):
                context.update({'dest_path': event.dest_path})
                command = 'echo "${watch_event_type} ${watch_object} from ${watch_src_path} to ${watch_dest_path}"'
            else:
                command = 'echo "${watch_event_type} ${watch_object} ${watch_src_path}"'
        else:
            if has_attribute(event, 'dest_path'):
                context.update({'watch_dest_path': event.dest_path})
            command = self.shell_command

        command = Template(command).safe_substitute(**context)
        self.process = subprocess.Popen(command, shell=True)
        if self.wait_for_process:
            self.process.wait()

    def on_any_event(self, event):
        from string import Template

        if event.is_directory:
            object_type = "directory"
        else:
            object_type = "file"

        context = {
            "watch_src_path": event.src_path,
            "watch_dest_path": "",
            "watch_event_type": event.event_type,
            "watch_object": object_type,
        }

        if self.shell_command is None:
            if has_attribute(event, "dest_path"):
                context.update({"dest_path": event.dest_path})
                command = 'echo "${watch_event_type} ${watch_object} from ${watch_src_path} to ${watch_dest_path}"'
            else:
                command = 'echo "${watch_event_type} ${watch_object} ${watch_src_path}"'
        else:
            if has_attribute(event, "dest_path"):
                context.update({"watch_dest_path": event.dest_path})
            command = self.shell_command

        command = Template(command).safe_substitute(**context)
        process = subprocess.Popen(command, shell=True)
        if self.wait_for_process:
            process.wait()

def get_file_event_paths(events):
    for event in events:
        for key in ('dest_path', 'src_path'):
            if has_attribute(event, key):
                path = unicode_paths.decode(getattr(event, key))
                if not (path.startswith('.autocheck.') or os.path.isdir(path)):
                    yield os.path.relpath(path)

    def dispatch(self, event):
        """Dispatches events to the appropriate methods.

        :param event:
            The event object representing the file system event.
        :type event:
            :class:`FileSystemEvent`
        """
        if self.ignore_directories and event.is_directory:
            return

        paths = []
        if has_attribute(event, 'dest_path'):
            paths.append(unicode_paths.decode(event.dest_path))
        if event.src_path:
            paths.append(unicode_paths.decode(event.src_path))

        if any(r.match(p) for r in self.ignore_regexes for p in paths):
            return

        if any(r.match(p) for r in self.regexes for p in paths):
            self.on_any_event(event)
            _method_map = {
                EVENT_TYPE_MODIFIED: self.on_modified,
                EVENT_TYPE_ATTR_MODIFIED: self.on_attr_modified,
                EVENT_TYPE_MOVED: self.on_moved,
                EVENT_TYPE_CREATED: self.on_created,
                EVENT_TYPE_DELETED: self.on_deleted,
            }
            event_type = event.event_type
            _method_map[event_type](event)

    def on_any_event(self, event):
        if self.drop_during_process and self.process and self.process.poll() is None:
            return

        if event.is_directory:
            object_type = 'directory'
        else:
            object_type = 'file'

        env = os.environ.copy()
        env.update({
            'WATCH_SRC_PATH': event.src_path,
            'WATCH_EVENT_TYPE': event.event_type,
            'WATCH_OBJECT': object_type,
        })
        if has_attribute(event, 'dest_path'):
            env['WATCH_DEST_PATH'] = event.dest_path

        if self.shell_command is None:
            if 'WATCH_DEST_PATH' in env:
                command = 'echo "$WATCH_EVENT_TYPE $WATCH_OBJECT from $WATCH_SRC_PATH to $WATCH_DEST_PATH"'
            else:
                command = 'echo "$WATCH_EVENT_TYPE $WATCH_OBJECT $WATCH_SRC_PATH"'
        else:
            command = self.shell_command

        self.process = subprocess.Popen(command, shell=True, env=env)
        if self.wait_for_process:
            self.process.wait()

 def assert_patterns(event):
     if has_attribute(event, 'dest_path'):
         paths = [event.src_path, event.dest_path]
     else:
         paths = [event.src_path]
     filtered_paths = filter_paths(paths, patterns, ignore_patterns)
     assert_true(filtered_paths)

 def dispatch(self, event):  
     if has_attribute(event, 'dest_path'):
         paths = [event.src_path, event.dest_path]
     else:
         paths = [event.src_path]
     if match_any_paths(paths, 
                        included_patterns=self.patterns, 
                        excluded_patterns=self.ignore_patterns):
         self.on_any_event(event)

 def assert_patterns(event):
   if has_attribute(event, 'dest_path'):
     paths = [event.src_path, event.dest_path]
   else:
     paths = [event.src_path]
   filtered_paths = filter_paths(paths,
                                 included_patterns=patterns,
                                 excluded_patterns=ignore_patterns,
                                 case_sensitive=False)
   self.assertTrue(filtered_paths)

 def assert_regexes(handler, event):
   if has_attribute(event, 'dest_path'):
     paths = [event.src_path, event.dest_path]
   else:
     paths = [event.src_path]
   filtered_paths = set()
   for p in paths:
     if any(r.match(p) for r in handler.regexes):
       filtered_paths.add(p)
   self.assertTrue(filtered_paths)

def assert_patterns(event):
    if has_attribute(event, 'dest_path'):
        paths = [event.src_path, event.dest_path]
    else:
        paths = [event.src_path]
    filtered_paths = filter_paths(
        paths,
        included_patterns=['*.py', '*.txt'],
        excluded_patterns=["*.pyc"],
        case_sensitive=False)
    assert filtered_paths

 def dispatch(self, event):
     if self.ignore_directories and event.is_directory:
         return
     paths = []
     if has_attribute(event, 'dest_path'):
         paths.append(unicode_paths.decode(event.dest_path))
     if event.src_path:
         paths.append(unicode_paths.decode(event.src_path))
     if match_any_paths(paths, included_patterns=self.patterns, excluded_patterns=self.ignore_patterns, case_sensitive=self.case_sensitive):
         self.on_any_event(event)
         _method_map = {EVENT_TYPE_MODIFIED: self.on_modified,
          EVENT_TYPE_MOVED: self.on_moved,
          EVENT_TYPE_CREATED: self.on_created,
          EVENT_TYPE_DELETED: self.on_deleted}
         event_type = event.event_type
         _method_map[event_type](event)

    def dispatch(self, event):
        try:
            paths = [event.src_path]
            if has_attribute(event, 'dest_path'):
                paths.append(event.dest_path)

            paths = [os.path.relpath(os.path.normpath(os.path.abspath(path)), start=self.source_base_path) for path in paths]
            event_type_to_name = {EVENT_TYPE_MOVED: "move", EVENT_TYPE_CREATED: "create",
                                  EVENT_TYPE_MODIFIED: "modify", EVENT_TYPE_DELETED: "delete"}
            vprint("local change type: {} paths: {}", event_type_to_name[event.event_type], paths)
            for path in paths:
                pattern = find_matching_pattern(path, self.source_ignore_patterns, match_subpath=True)
                if pattern:
                    vprint("ignoring change for path {}, pattern: {}", path, pattern)
                    return

            self.queue.put(event)
        except:
            import traceback
            traceback.print_exc()

    def dispatch(self, event):
        """Only dispatch if the event does not correspond to an ignored file.
        Args:
            event (watchdog.events.FileSystemEvent)
        """
        if event.is_directory:
            return
        paths = []
        if has_attribute(event, 'dest_path'):
            paths.append(os.path.realpath(
                unicode_paths.decode(event.dest_path)))
        if event.src_path:
            paths.append(os.path.realpath(
                unicode_paths.decode(event.src_path)))
        paths = [p for p in paths
                 if not p.startswith(os.path.realpath(self.vcs.repository_dir()))
                 and not self.vcs.path_is_ignored(p)]

        if len(paths) > 0:
            super(VcsEventHandler, self).dispatch(event)

    def dispatch(self, event):
        """Dispatch an event after filtering. We handle
        creation and move events only.
        
        :param event: watchdog event.

        :returns: None
        """
        if event.event_type not in (EVENT_TYPE_CREATED, EVENT_TYPE_MOVED):
            return
        if self.ignore_directories and event.is_directory:
            return

        paths = []
        if has_attribute(event, 'dest_path'):
            paths.append(unicode_paths.decode(event.dest_path))
        if event.src_path:
            paths.append(unicode_paths.decode(event.src_path))

        if any(r.match(p) for r in self.ignore_regexes for p in paths):
            return

        if any(r.match(p) for r in self.regexes for p in paths):
            self._loop.call_soon_threadsafe(asyncio.async, self._process_file(event))

    DirModifiedEvent,\
    DirMovedEvent,\
    DirCreatedEvent,\
    FileDeletedEvent,\
    FileModifiedEvent,\
    FileMovedEvent,\
    FileCreatedEvent,\
    EVENT_TYPE_MODIFIED,\
    EVENT_TYPE_CREATED,\
    EVENT_TYPE_DELETED,\
    EVENT_TYPE_MOVED

  libc_string = ctypes_find_library('c', 'libc.so.6')
  libc = ctypes.CDLL(libc_string, use_errno=True)

  if (not has_attribute(libc, 'inotify_init') or
      not has_attribute(libc, 'inotify_add_watch') or
      not has_attribute(libc, 'inotify_rm_watch')):
    raise ImportError("Unsupported libc version found: %s" % libc_string)

  # #include <sys/inotify.h>
  # char *strerror(int errnum);
  #strerror = ctypes.CFUNCTYPE(c_char_p, c_int)(
  #    ("strerror", libc))

  # #include <sys/inotify.h>
  # int inotify_init(void);
  inotify_init = ctypes.CFUNCTYPE(c_int, use_errno=True)(
    ("inotify_init", libc))

  # #include <sys/inotify.h>

from __future__ import with_statement
import os
import errno
import struct
import threading
import ctypes
from functools import reduce
from ctypes import c_int, c_char_p, c_uint32
from watchdog.utils import has_attribute, ctypes_find_library


libc_string = ctypes_find_library("c", "libc.so")
libc = ctypes.CDLL(libc_string, use_errno=True)

if (
    not has_attribute(libc, "inotify_init")
    or not has_attribute(libc, "inotify_add_watch")
    or not has_attribute(libc, "inotify_rm_watch")
):
    raise ImportError("Unsupported libc version found: %s" % libc_string)

inotify_add_watch = ctypes.CFUNCTYPE(c_int, c_int, c_char_p, c_uint32, use_errno=True)(("inotify_add_watch", libc))

inotify_rm_watch = ctypes.CFUNCTYPE(c_int, c_int, c_uint32, use_errno=True)(("inotify_rm_watch", libc))

inotify_init = ctypes.CFUNCTYPE(c_int, use_errno=True)(("inotify_init", libc))

try:
    inotify_init1 = ctypes.CFUNCTYPE(c_int, c_int, use_errno=True)(("inotify_init1", libc))
except AttributeError:

        # errors, e.g.on android IOError "No usable temporary directory found"
        # will be raised.
        pass

    if libc_path is not None:
        return ctypes.CDLL(libc_path)

    # Fallbacks
    try:
        return ctypes.CDLL('libc.so')
    except (OSError, IOError):
        return ctypes.CDLL('libc.so.6')

libc = _load_libc()

if not has_attribute(libc, 'inotify_init') or \
        not has_attribute(libc, 'inotify_add_watch') or \
        not has_attribute(libc, 'inotify_rm_watch'):
    raise UnsupportedLibc("Unsupported libc version found: %s" % libc._name)

inotify_add_watch = ctypes.CFUNCTYPE(c_int, c_int, c_char_p, c_uint32, use_errno=True)(
    ("inotify_add_watch", libc))

inotify_rm_watch = ctypes.CFUNCTYPE(c_int, c_int, c_uint32, use_errno=True)(
    ("inotify_rm_watch", libc))

inotify_init = ctypes.CFUNCTYPE(c_int, use_errno=True)(
    ("inotify_init", libc))


class InotifyConstants(object):