Python PollingObserver.schedule方法代码示例

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import schedule [as 别名]
    def watch(self):
        """
        Start watching
        """
        logger.info('Watching directory %s' % self.directory)

        # Set up handler for when we see new files
        callback = self.callback
        class NewFileEventHandler(FileSystemEventHandler):
            def on_created(self, event):
                if not event.is_directory:
                    logger.info('Detected new file: %s' % event.src_path)
                    callback(event.src_path)
        event_handler = NewFileEventHandler()

        # Use polling observer (rather than filesystem-specific observers),
        # because it is more reliable.
        observer = PollingObserver(timeout=self.sleep_time)

        # Start the observer
        observer.schedule(event_handler, self.directory, recursive=False)
        observer.start()

        # Wait while the observer is running
        try:
            while True:
                sleep(self.sleep_time)
        # Exit gracefully
        except KeyboardInterrupt:
            logger.info('Detected interrupt. Stopping observer.')
            observer.stop()
        observer.join()

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import schedule [as 别名]
 def watch(self):
     observer = PollingObserver(0.1)
     observer.schedule(self, self.path)
     observer.start()
     self.file = open(self.path + "\Power.log", "r")
     self.on_modified(None)
     self.watching = True

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import schedule [as 别名]
class Crafter(object):
    """
    Setup and manage watchdog daemon.
    """
    def __init__(self, base_dir):
        # Cache paths
        src_dir = os.path.join(base_dir, 'src')
        dest_dir = os.path.join(base_dir, 'preview')
        # Init handler
        self.handler = ObserverHandler(src_dir, dest_dir)
        # New observer class
        self.observer = Observer()
        self.observer.schedule(self.handler, path=src_dir, recursive=True)

    def craft(self):
        """
        Start watching src directory
        """
        self.observer.start()

    def shutdown(self):
        """
        Properly shutdown watchdog daemon
        """
        self.observer.stop()
        self.observer.join()

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import schedule [as 别名]
def watch_record(indexer, use_polling=False):
    """
    Start watching `cfstore.record_path`.

    :type indexer: rash.indexer.Indexer

    """
    if use_polling:
        from watchdog.observers.polling import PollingObserver as Observer

        Observer  # fool pyflakes
    else:
        from watchdog.observers import Observer

    event_handler = RecordHandler(indexer)
    observer = Observer()
    observer.schedule(event_handler, path=indexer.record_path, recursive=True)
    indexer.logger.debug("Start observer.")
    observer.start()
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        indexer.logger.debug("Got KeyboardInterrupt. Stopping observer.")
        observer.stop()
    indexer.logger.debug("Joining observer.")
    observer.join()
    indexer.logger.debug("Finish watching record.")

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import schedule [as 别名]
def watch(directory=None, auto_clear=False, beep_on_failure=True,
          onpass=None, onfail=None, poll=False, extensions=[]):
    """
    Starts a server to render the specified file or directory
    containing a README.
    """
    if directory and not os.path.isdir(directory):
        raise ValueError('Directory not found: ' + directory)
    directory = os.path.abspath(directory or '')

    # Initial run
    event_handler = ChangeHandler(directory, auto_clear, beep_on_failure,
                                  onpass, onfail, extensions)
    event_handler.run()

    # Setup watchdog
    if poll:
        observer = PollingObserver()
    else:
        observer = Observer()

    observer.schedule(event_handler, path=directory, recursive=True)
    observer.start()

    # Watch and run tests until interrupted by user
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import schedule [as 别名]
def get_contracts_code_observer(project_dir):
    observer = PollingObserver()

    build_path = utils.get_build_dir(project_dir)
    event_handler = ContractCodeChangedEventHandler(project_dir=project_dir)
    observer.schedule(event_handler, build_path, recursive=False)

    return observer

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import schedule [as 别名]
def watch_server(root_dir):
    # create event handler
    event_handler = OneDirServerEventHandler()
    # create observer
    observer = PollingObserver()

    # observe the given directory recursively
    observer.schedule(event_handler, path=root_dir, recursive=True)
    return observer

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import schedule [as 别名]
def get_active_dir_observer(project_dir, event_handler):
    """ Setup a polling observer on the project's
        blockchains directory. This directory contains the
        .active-chain symlink which is watched for.
    """
    bchain = get_blockchains_dir(project_dir)
    observer = PollingObserver()
    observer.schedule(event_handler, bchain, recursive=False)
    return observer

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import schedule [as 别名]
def watch(script, callback):
    if script in _observers:
        raise RuntimeError("Script already observed")
    script_dir = os.path.dirname(os.path.abspath(script.filename))
    script_name = os.path.basename(script.filename)
    event_handler = _ScriptModificationHandler(callback, filename=script_name)
    observer = Observer()
    observer.schedule(event_handler, script_dir)
    observer.start()
    _observers[script] = observer

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import schedule [as 别名]
class Watcher:
    def __init__(self):
#       self.observer = Observer()            # Use this if SS_DIR is local
        self.observer = PollingObserver()     # Use this if SS_DIR is remote mount

    def run(self):
        event_handler = file_changed()
        self.observer.schedule(event_handler, SS_DIR, recursive=True)
        self.observer.start()
        loop1()

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import schedule [as 别名]
 def __init__(self, index, interface='wlan0'):
     self.interface = interface
     self.run_state = '/run/network/ifstate.{interface}'.format(interface=interface)
     self.configurations = ['', interface] + rospy.get_param("~wlan_interfaces", [])
     rospy.loginfo("Loaded wlan configs %s", self.configurations)
     super(WifiUI, self).__init__(index, len(self.configurations))
     self.config = get_configuration(self.run_state, self.configurations)
     rospy.loginfo("Start observingchanges in %s", os.path.dirname(self.run_state))
     observer = Observer()
     observer.schedule(self, os.path.dirname(self.run_state), recursive=True)
     observer.start()

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import schedule [as 别名]
    def watch(self):
        observer = PollingObserver()
        observer.schedule(self.pickup_event_processor, path=self.pickup_dir)
        observer.start()
        
        try:
            while self.keep_running:
                sleep(3)
        except KeyboardInterrupt:
            observer.stop()

        observer.join()

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import schedule [as 别名]
def watch(
    directories=[],
    ignore=[],
    auto_clear=False,
    beep_on_failure=True,
    onpass=None,
    onfail=None,
    runner=None,
    beforerun=None,
    onexit=None,
    poll=False,
    extensions=[],
    args=[],
    spool=True,
    verbose=False,
    quiet=False,
):
    if not directories:
        directories = ["."]
    directories = [os.path.abspath(directory) for directory in directories]
    for directory in directories:
        if not os.path.isdir(directory):
            raise ValueError("Directory not found: " + directory)

    if ignore:
        recursive_dirs, non_recursive_dirs = split_recursive(directories, ignore)
    else:
        recursive_dirs = directories
        non_recursive_dirs = []

    # Initial run
    event_handler = ChangeHandler(
        auto_clear, beep_on_failure, onpass, onfail, runner, beforerun, extensions, args, spool, verbose, quiet
    )
    event_handler.run()

    # Setup watchdog
    observer = PollingObserver() if poll else Observer()
    for directory in recursive_dirs:
        observer.schedule(event_handler, path=directory, recursive=True)
    for directory in non_recursive_dirs:
        observer.schedule(event_handler, path=directory, recursive=False)

    # Watch and run tests until interrupted by user
    try:
        observer.start()
        while True:
            time.sleep(1)
        observer.join()
    except KeyboardInterrupt:
        observer.stop()
    if onexit:
        os.system(onexit)

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import schedule [as 别名]
def get_static_assets_observer(project_dir):
    build_path = utils.get_build_dir(project_dir)

    observer = PollingObserver()

    contracts_js_event_handler = ContractsJSChangedEventHandler(project_dir=project_dir)
    observer.schedule(contracts_js_event_handler, build_path, recursive=False)

    if project_has_assets(project_dir):
        assets_watch_path = get_static_assets_dir(project_dir)
        assets_event_handler = AssetsChangedEventHandler(project_dir=project_dir)
        observer.schedule(assets_event_handler, assets_watch_path, recursive=True)

    return observer

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import schedule [as 别名]
def get_contracts_observer(project_dir, contract_filters=None, compiler_kwargs=None):
    if contract_filters is None:
        contract_filters = []
    if compiler_kwargs is None:
        compiler_kwargs = {}
    contracts_dir = utils.get_contracts_dir(project_dir)
    libraries_dir = get_project_libraries_dir(project_dir)

    event_handler = ContractSourceChangedEventHandler(
        project_dir=project_dir, contract_filters=contract_filters, compiler_kwargs=compiler_kwargs
    )
    observer = PollingObserver()
    observer.schedule(event_handler, contracts_dir, recursive=True)
    observer.schedule(event_handler, libraries_dir, recursive=True)
    return observer