Python PollingObserver.start方法代码示例

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import start [as 别名]
def main():
    """Script entry point."""
    from watchdog.observers.polling import PollingObserver
    from .parser import AAConfigParser
    from .tricks import AutoRunTrick

    parser = _create_main_argparser()
    args = parser.parse_args()
    configm = _apply_main_args(args)

    # The reason to use PollingObserver() is it's os-independent. And it's
    # more reliable.
    observer = PollingObserver()

    parser = AAConfigParser(configm)
    handler_for_watch = parser.schedule_with(observer, AutoRunTrick)
    handlers = set.union(*tuple(handler_for_watch.values()))

    for handler in handlers:
        handler.start()
    observer.start()
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()
    for handler in handlers:
        handler.stop()

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import start [as 别名]
def watch_assets(options):
    """
    Watch for changes to asset files, and regenerate js/css
    """
    # Don't watch assets when performing a dry run
    if tasks.environment.dry_run:
        return

    observer = PollingObserver()

    CoffeeScriptWatcher().register(observer)
    SassWatcher().register(observer)
    XModuleSassWatcher().register(observer)
    XModuleAssetsWatcher().register(observer)

    print("Starting asset watcher...")
    observer.start()
    if not getattr(options, 'background', False):
        # when running as a separate process, the main thread needs to loop
        # in order to allow for shutdown by contrl-c
        try:
            while True:
                observer.join(2)
        except KeyboardInterrupt:
            observer.stop()
        print("\nStopped asset watcher.")

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import start [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 start [as 别名]
def main():
    if int(os.getuid()) != 0:
        raise SystemExit("ERROR: this script should be run as root")

    parser = ArgumentParser(description='Watch a directory and install the code')
    args = parser.parse_args()

    current_path = Path(__file__).resolve().parent
    setup_path = Path(current_path, '..').resolve()
    git_path = Path(current_path, '..', '..').resolve()

    observer = Observer()
    observer.schedule(FileHandler(setup_path, 'site'), str(Path(git_path, 'site')), True)
    observer.schedule(FileHandler(setup_path, 'bin'), str(Path(git_path, 'bin')), True)
    observer.schedule(FileHandler(setup_path, 'bin'), str(Path(git_path, 'sbin')), True)

    observer.start()
    try:
        print("Watching the following folders for change:")
        print("    - site")
        print("    - bin")
        print("    - sbin")
        print()
        input("~~Hit enter to exit~~\n")
    finally:
        observer.stop()
        observer.join()

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import start [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 start [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 start [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 start [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 start [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 start [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 start [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 start [as 别名]
def serve(config, options=None):
    """
    Start the devserver, and rebuild the docs whenever any changes take effect.
    """
    # Create a temporary build directory, and set some options to serve it
    tempdir = tempfile.mkdtemp()
    options['site_dir'] = tempdir

    # Only use user-friendly URLs when running the live server
    options['use_directory_urls'] = True

    # Perform the initial build
    config = load_config(options=options)
    build(config, live_server=True)

    # Note: We pass any command-line options through so that we
    #       can re-apply them if the config file is reloaded.
    event_handler = BuildEventHandler(options)
    config_event_handler = ConfigEventHandler(options)

    # We could have used `Observer()`, which can be faster, but
    # `PollingObserver()` works more universally.
    observer = PollingObserver()
    observer.schedule(event_handler, config['docs_dir'], recursive=True)
    for theme_dir in config['theme_dir']:
        if not os.path.exists(theme_dir):
            continue
        observer.schedule(event_handler, theme_dir, recursive=True)
    observer.schedule(config_event_handler, '.')
    observer.start()

    class TCPServer(socketserver.TCPServer):
        allow_reuse_address = True

    class DocsDirectoryHandler(FixedDirectoryHandler):
        base_dir = config['site_dir']

    host, port = config['dev_addr'].split(':', 1)
    server = TCPServer((host, int(port)), DocsDirectoryHandler)

    print('Running at: http://%s:%s/' % (host, port))
    print('Live reload enabled.')
    print('Hold ctrl+c to quit.')
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print('Stopping server...')

    # Clean up
    observer.stop()
    observer.join()
    shutil.rmtree(tempdir)
    print('Quit complete')

# 需要导入模块: from watchdog.observers.polling import PollingObserver [as 别名]
# 或者: from watchdog.observers.polling.PollingObserver import start [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 start [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 start [as 别名]
class SuiteTable(object):
    def __init__(self, dbfile=":memory:", poll=False):
        self.db = sqlite3.connect(dbfile, check_same_thread=False)
        self.log = logging.getLogger(__name__)
        self._create_db()

        # set up watchdog observer to monitor changes to
        # keyword files (or more correctly, to directories
        # of keyword files)
        self.observer =  PollingObserver() if poll else Observer()
        self.observer.start()

    def _create_db(self):

        if not self._table_exists("collection_table"):
            self.db.execute("""
                CREATE TABLE collection_table
                (collection_id INTEGER PRIMARY KEY AUTOINCREMENT,
                 name          TEXT COLLATE NOCASE,
                 type          COLLATE NOCASE,
                 version       TEXT,
                 scope         TEXT,
                 namedargs     TEXT,
                 path          TEXT,
                 doc           TEXT,
                 doc_format    TEXT)
            """)
            self.db.execute("""
                CREATE INDEX collection_index
                ON collection_table (name)
            """)

        if not self._table_exists("keyword_table"):
            self.db.execute("""
                CREATE TABLE keyword_table
                (keyword_id    INTEGER PRIMARY KEY AUTOINCREMENT,
                 name          TEXT COLLATE NOCASE,
                 collection_id INTEGER,
                 doc           TEXT,
                 args          TEXT)
            """)
            self.db.execute("""
                CREATE INDEX keyword_index
                ON keyword_table (name)
            """)

    def _table_exists(self, name):
        cursor = self.db.execute("""
            SELECT name FROM sqlite_master
            WHERE type='table' AND name='%s'
        """ % name)
        return len(cursor.fetchall()) > 0