def __init__(self, event_queue, watch, timeout=DEFAULT_EMITTER_TIMEOUT):
      EventEmitter.__init__(self, event_queue, watch, timeout)
      self._lock = threading.Lock()

      self._directory_handle = get_directory_handle(watch.path,
                                                    WATCHDOG_FILE_FLAGS)
      self._buffer = ctypes.create_string_buffer(BUFFER_SIZE)

 def __init__(self, event_queue, watch, timeout=DEFAULT_EMITTER_TIMEOUT):
     EventEmitter.__init__(self, event_queue, watch, timeout)
     self.wm = pyinotify.WatchManager()
     self.notifier = pyinotify.Notifier(self.wm, InotifyEventHandler(emitter=self))
     self.wm.add_watch(watch.path, mask, rec=watch.is_recursive)
     self.stopped = threading.Event()
     self.path = watch.path

 def __init__(self, event_queue, watch, timeout=DEFAULT_EMITTER_TIMEOUT,
              stat=default_stat, listdir=os.listdir):
     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 queue_event(self, event):
     EventEmitter.queue_event(self, event)
     if event.event_type == EVENT_TYPE_CREATED:
         self._register_kevent(event.src_path, event.is_directory)
     elif event.event_type == EVENT_TYPE_MOVED:
         self._unregister_kevent(event.src_path)
         self._register_kevent(event.dest_path, event.is_directory)
     elif event.event_type == EVENT_TYPE_DELETED:
         self._unregister_kevent(event.src_path)

    def __init__(self, event_queue, watch, timeout = DEFAULT_EMITTER_TIMEOUT):
        EventEmitter.__init__(self, event_queue, watch, timeout)
        self._kq = select.kqueue()
        self._lock = threading.RLock()
        self._descriptors = KeventDescriptorSet()

        def walker_callback(path, stat_info, self = self):
            self._register_kevent(path, stat.S_ISDIR(stat_info.st_mode))

        self._snapshot = DirectorySnapshot(watch.path, watch.is_recursive, walker_callback)

    def queue_event(self, event):
        """
        Handles queueing a single event object.

        :param event:
            An instance of :class:`watchdog.events.FileSystemEvent`
            or a subclass.
        """
        # Handles all the book keeping for queued events.
        # We do not need to fire moved/deleted events for all subitems in
        # a directory tree here, because this function is called by kqueue
        # for all those events anyway.
        EventEmitter.queue_event(self, event)
        if event.event_type == EVENT_TYPE_CREATED:
            self._register_kevent(event.src_path, event.is_directory)
        elif event.event_type == EVENT_TYPE_MOVED:
            self._unregister_kevent(event.src_path)
            self._register_kevent(event.dest_path, event.is_directory)
        elif event.event_type == EVENT_TYPE_DELETED:
            self._unregister_kevent(event.src_path)

 def __init__(self, event_queue, watch, timeout=DEFAULT_EMITTER_TIMEOUT):
   EventEmitter.__init__(self, event_queue, watch, timeout)
   self._lock = threading.Lock()
   self._inotify = Inotify(watch.path, watch.is_recursive)

 def __init__(self, event_queue, watch, timeout=DEFAULT_EMITTER_TIMEOUT):
     EventEmitter.__init__(self, event_queue, watch, timeout)
     self._snapshot = DirectorySnapshot(watch.path, watch.is_recursive)
     self._lock = threading.Lock()

 def test___init__(self):
   event_queue = EventQueue()
   watch = ObservedWatch('/foobar', True)
   event_emitter = EventEmitter(event_queue, watch, timeout=1)
   event_emitter.queue_event(FileModifiedEvent('/foobar/blah'))

 def __init__(self, event_queue, watch, timeout=DEFAULT_EMITTER_TIMEOUT):
     EventEmitter.__init__(self, event_queue, watch, timeout)
     self._lock = threading.Lock()
     self._inotify = None

 def __init__(self, event_queue, watch, timeout=DEFAULT_EMITTER_TIMEOUT):
     EventEmitter.__init__(self, event_queue, watch, timeout)
     self._fsevents = FSEventsQueue(watch.path)
     self._fsevents.start()

 def __init__(self, event_queue, watch, make_snapshot, timeout):
   EventEmitter.__init__(self, event_queue, watch, timeout)
   self._make_snapshot = make_snapshot
   self._snapshot = make_snapshot(self.watch.path)

            return
        logging.debug(event)

    def on_created(self, event):
        logging.debug(event)

    def on_deleted(self, event):
        logging.debug(event)

    def on_modified(self, event):
        logging.debug(event)

#path = sys.argv[1]
qu = EventQueue()
ob_w = ObservedWatch(path,True)
em = EventEmitter(qu,ob_w,1)

em.start()
t = True
try:
    while 1:
        if qu.task_done():
            time.sleep(3)
        else:
            logging.info("{0:s}".format(qu.get()))

except KeyboardInterrupt:
    em.stop()
em.stop()
em.join()

 def __init__(self, event_queue, watch, timeout=DEFAULT_EMITTER_TIMEOUT):
     EventEmitter.__init__(self, event_queue, watch, timeout)
     self._lock = threading.Lock()
     self._handle = get_directory_handle(watch.path)

 def __init__(self, event_queue, watch, timeout=1):
     EventEmitter.__init__(self, event_queue, watch, timeout)
     self._snapshot = None