def __init__(self, path, mask, callbacks, pending_delay): FileSystemEventHandler.__init__(self) self._path = path self._mask = mask self._callbacks = callbacks self._pending_delay = pending_delay self._pending = set()
def __init__(self): FileSystemEventHandler.__init__(self) # futureproofing - not need for current version of watchdog self.root = None self.currentdir = None # The actual logdir that we're monitoring self.logfile = None self.observer = None self.observed = None # a watchdog ObservedWatch, or None if polling self.thread = None self.event_queue = [] # For communicating journal entries back to main thread # Context for journal handling self.version = None self.is_beta = False self.mode = None self.group = None self.cmdr = None self.shipid = None self.shiptype = None self.shippaint = None self.body = None self.system = None self.station = None self.coordinates = None self.ranks = None self.credits = None
def __init__(self, window): super(Client, self).__init__() self.window = window self.width, self.height = glfw.get_window_size(window) self.gl = mg.create_context() self.compile() self.camerapos = vec4(0.0, 0.0, 20.0, 1.0) def on_modified(e): # restart python if python code is changed if e.src_path.endswith(".py"): glfw.set_window_should_close(window, glfw.TRUE) os.system(f"python {e.src_path}") # compile shaders if the change is not python code else: self.should_compile = True handler = FileSystemEventHandler() handler.on_modified = on_modified observer = Observer() observer.schedule(handler, "./.", True) observer.start() self.is_drag_rot_cam = False self.prempos = vec2(0.0, 0.0) # wire glfw events glfw.set_mouse_button_callback(window, self.on_mouse_button) glfw.set_cursor_pos_callback(window, self.on_cursor_pos) glfw.set_scroll_callback(window, self.on_scroll) glfw.set_window_size_callback(window, self.on_window_size)
def run(self) -> None: self._logger.info("Started running the server") event_handler = FileSystemEventHandler() event_handler.on_created = self._process_file_system_event event_handler.on_modified = self._process_file_system_event observer = Observer() observer.schedule(event_handler, self._configuration.upload_directory, recursive=True) observer.start() try: while True: time.sleep(1) except Exception: self._logger.exception( "An unexpected exception occurred during watching file changes" ) observer.stop() observer.join() self._logger.info("Finished running the server")
def __init__(self): FileSystemEventHandler.__init__(self) # futureproofing - not need for current version of watchdog self.root = None self.currentdir = None # The actual logdir that we're monitoring self.observer = None self.observed = None # a watchdog ObservedWatch, or None if polling self.status = {} # Current status for communicating status back to main thread
def __init__(self, holder, configfile, *args, **kwargs): FileSystemEventHandler.__init__(self, *args, **kwargs) self._file = None self._filename = "" self._where = 0 self._satellite = "" self._orbital = None cfg = ConfigParser() cfg.read(configfile) self._coords = cfg.get("local_reception", "coordinates").split(" ") self._coords = [float(self._coords[0]), float(self._coords[1]), float(self._coords[2])] self._station = cfg.get("local_reception", "station") logger.debug("Station " + self._station + " located at: " + str(self._coords)) try: self._tle_files = cfg.get("local_reception", "tle_files") except NoOptionError: self._tle_files = None self._file_pattern = cfg.get("local_reception", "file_pattern") self.scanlines = holder self._warn = True
def __init__(self, *args, **kwargs): self.rate = 4 self.surface = pygame.Surface((1, 1)) self.size = (0, 0) self.fade = False self.screensize = kwargs.pop("screensize") FileSystemEventHandler.__init__(self, *args, **kwargs)
def watchdog_monitor(): def on_created(event): print(type(event)) print(event.src_path) if event.src_path[-4:] == ".xls": print("true") time.sleep(1) confirm(event.src_path) json_f = json.load(open("tmp/config.json")) event_handler = FileSystemEventHandler() event_handler.on_created = on_created path = json_f['defaultPath'] observer = Observer() observer.schedule(event_handler, path, recursive=True) observer.start() try: while True: time.sleep(1) except KeyboardInterrupt: observer.stop() observer.join()
def __init__(self): FileSystemEventHandler.__init__(self) super().__init__() self.locked_groups = [] try: pass self.load_state() self.displaygen() except: self.display = "" self.groups = [] self.monitors = {} monitors = command("bspc query -M --names").strip().split("\n") for monitor in monitors: self.monitors[monitor] = [] workspaces = command("bspc query -D -m " + monitor + " --names").strip().split("\n") command("bspc desktop -f " + workspaces[0]) self.groups.append(Group()) self.activegroup = self.groups[-1] self.activegroup.workspaces = [ workspace for workspace in workspaces ] try: command("rm {}*".format(config["command_folder"])) except: pass self.displaygen()
def __init__(self, file_path, host="192.168.1.25", port=1234): FileSystemEventHandler.__init__(self) self.file_path = file_path self._host = host self._port = port self._regex = re.compile(r"^(?P<artist>.*) - (?P<title>.*)$") self._last_sent = time.time()
def __init__(self): """ Constructor :return: """ FileSystemEventHandler.__init__(self) self.app = app._get_current_object()
def __init__(self, monitor_dir, config): FileSystemEventHandler.__init__(self) self.monitor_dir = monitor_dir if not config: config = {} self.scan_interval = config.get('scan_interval', 3) # If no updates in 3 seconds (or user specified option in config file) process file
def __init__(self, path, mask, callbacks, pending_delay): FileSystemEventHandler.__init__(self) self._path = path self._mask = mask self._callbacks = callbacks self._pending_delay = pending_delay self._pending = set()
def __init__(self, window): super(Client, self).__init__() self.window = window glfw.make_context_current(window) self.gl = mg.create_context() self.need_compile = False imgui.create_context() win_size = glfw.get_window_size(window) self.imgui = ModernGLRenderer(ctx=self.gl, display_size=win_size) quad = Quad(self.gl, vspath="./gl/quad.vs", fspath="./gl/quad.fs") self.children = [] self.children.append(quad) def onmod(e): self.need_compile = True handler = FileSystemEventHandler() handler.on_modified = onmod shader_code_observer = Observer() shader_code_observer.schedule(handler, "./gl", True) shader_code_observer.start() self.wire_glfw_to_imgui_events() self.last_time = 0 self.u_camera_rotation_xz = 0.0 self.u_camera_zoom = 1.0
def __init__(self, project_id, handler_type='project'): # Initialize. self.project_id = project_id FileSystemEventHandler.__init__(self) # Handler is a project file handler... if handler_type == 'project': log_msg = ('PROJECT_EVENT_HANDLER initialized for project ' 'with ID {project_id}') self.actions = { 'Created': self._on_created_project, 'Deleted': self._on_deleted_project, 'Modified': self._on_modified_project, 'Moved': self._on_moved_project } # Handler is a project scanner handler. elif handler_type == 'scanner': log_msg = ('Project image scan handler initialized for project ' 'with ID {project_id}') self.actions = {'Created': self._on_created_scanner} # Undefined handler type. else: raise NotImplementedError() # Populate the log_mgs with data and log. log_msg = log_msg.format(**self.__dict__) _logger().debug(log_msg)
def __init__(self, window): super().__init__() self.window = window self.width, self.height = WIDTH, HEIGHT self.gl = mg.create_context() self.rotation = vec2(0.0, 0.0) self.u_campos = vec3(-2.0, 2.0, 5.0) self._prevpos = ivec2(0, 0) self._isdrag = False self.compile_shaders() def _on_mod(e): self.should_compile = True handler = FileSystemEventHandler() handler.on_modified = _on_mod observer = Observer() observer.schedule(handler, "./gl", True) observer.schedule(handler, "./tex", True) observer.start() imgui.create_context() self.imgui = ModernGLGLFWRenderer(ctx=self.gl, display_size=(WIDTH, HEIGHT)) self.imgui.wire_events(self.gl, window) self.imgui.on_mouse_button = self.on_mouse_button self.imgui.on_cursor_pos = self.on_cursor_pos
def run(self): observer = Observer() handler = FileSystemEventHandler() handler.on_modified = self.on_modified_event observer.schedule(handler, "./gl") observer.start() observer.join()
def __init__(self): FileSystemEventHandler.__init__( self) # futureproofing - not need for current version of watchdog self.root = None self.currentdir = None # The actual logdir that we're monitoring self.logfile = None self.observer = None self.observed = None # a watchdog ObservedWatch, or None if polling self.thread = None self.event_queue = [ ] # For communicating journal entries back to main thread # On startup we might be: # 1) Looking at an old journal file because the game isn't running or the user has exited to the main menu. # 2) Looking at an empty journal (only 'Fileheader') because the user is at the main menu. # 3) In the middle of a 'live' game. # If 1 or 2 a LoadGame event will happen when the game goes live. # If 3 we need to inject a special 'StartUp' event since consumers won't see the LoadGame event. self.live = False self.game_was_running = False # For generation the "ShutDown" event # Context for journal handling self.version = None self.is_beta = False self.mode = None self.group = None self.cmdr = None self.planet = None self.system = None self.station = None self.stationtype = None self.coordinates = None self.systemaddress = None self.started = None # Timestamp of the LoadGame event self.missioncargo = {} # For tracking cargo in wing missions # Cmdr state shared with EDSM and plugins self.state = { 'Captain': None, # On a crew 'Cargo': defaultdict(int), 'Credits': None, 'Loan': None, 'Raw': defaultdict(int), 'Manufactured': defaultdict(int), 'Encoded': defaultdict(int), 'Rank': {}, 'Reputation': {}, 'Statistics': {}, 'Role': None, # Crew role - None, Idle, FireCon, FighterCon 'Friends': set(), # Online friends 'ShipID': None, 'ShipIdent': None, 'ShipName': None, 'ShipType': None, 'HullValue': None, 'ModulesValue': None, 'Rebuy': None, 'Modules': None, }
def watch( # noqa: C901 func: callable, path: str = None, *, poll_time=0.5, skip_first=False, name=None): """ Execute function and re-execute if everytime a file under the given path changes. """ import time from watchdog.observers import Observer from watchdog.events import ( FileSystemEventHandler, FileCreatedEvent, FileDeletedEvent, FileModifiedEvent, FileMovedEvent, ) # Create the dispatch function that throttles execution so func is # executed at most every poll_time seconds file_event = (FileCreatedEvent, FileDeletedEvent, FileModifiedEvent, FileMovedEvent) last = time.time() def dispatch(ev): nonlocal last if (ev.src_path.endswith("__") or ev.src_path.startswith("__") or ev.src_path.startswith("~") or ev.src_path.startswith(".")): return if isinstance(ev, file_event): last = start = time.time() time.sleep(poll_time) if last == start: print(f"File modified: {ev.src_path}") func() # Initialize observer and mokey-match the instance dispatch method observer = Observer() handler = FileSystemEventHandler() handler.dispatch = dispatch observer.schedule(handler, path or os.getcwd(), recursive=True) observer.start() name = name or func.__name__ # Starts execution loop print(f"Running {name} in watch mode.") if not skip_first: func() try: while True: time.sleep(0.5) except KeyboardInterrupt: observer.stop() observer.join()
def initialize_gl(self): self.gl = mg.create_context() self.gl.disable(mg.CULL_FACE) NUM_VERTICES = 8 NUM_QUADS = 6 self.vbo = self.gl.buffer(reserve=NUM_VERTICES * 3 * 4) self.vbo.bind_to_storage_buffer(0) self.normals_bo = self.gl.buffer(reserve=NUM_VERTICES * 3 * 4) self.normals_bo.bind_to_storage_buffer(1) self.ibo = self.gl.buffer(reserve=3 * 2 * NUM_QUADS * 4) self.ibo.bind_to_storage_buffer(2) self.vbo_content = self.regenerate_verts_content() self.recompile_vao() def on_mod(e): self.should_recompile_vao = True handler = FileSystemEventHandler() handler.on_modified = on_mod observer = Observer() observer.schedule(handler, "./gl") observer.start()
def __init__(self, gl_win, width, height): super(Renderer, self).__init__() self.window = gl_win self.width, self.height = width, height self.gl = mg.create_context() self.vbo = self.gl.buffer(reserve=4 * 4 * 4) self.ibo = self.gl.buffer(reserve=6 * 4) self.vbo.bind_to_storage_buffer(0) self.ibo.bind_to_storage_buffer(1) self.const = self.gl.buffer(reserve=1024) self.const.bind_to_storage_buffer(15) self.build_vao() def onmod(e): self.should_compile = True h = FileSystemEventHandler() h.on_modified = onmod o = Observer() o.schedule(h, "./gl/", True) o.start()
def __init__(self, fun, publisher, pattern, attrs): """Initialize the processor.""" FileSystemEventHandler.__init__(self) self.fun = fun self.publisher = publisher self.pattern = pattern self.attrs = attrs
def __init__(self, name, queue): FileSystemEventHandler.__init__(self) self.name = name self.queue = queue self.set = set() self.num = 0 self.no = 0
def __init__(self, file_path, window): FileSystemEventHandler.__init__(self) self.file_path = os.path.normpath(file_path) self.last_position = 0 self.signal = None self.signal = window.new_window self.ProcessCommands()
def watch_note(note, handle_func): """watch a single note for changes, call `handle_func` on change""" ob = Observer() handler = FileSystemEventHandler() note_filename = path.basename(note) def handle_event(event): _, filename = path.split(event.src_path) if note_filename == filename or \ path.normpath(event.src_path) == path.normpath(util.assets_dir(note)): print('compiling...') handle_func(note) print('done') handler.on_any_event = handle_event print('watching "{0}"...'.format(note_filename)) ob.schedule(handler, path.dirname(note), recursive=True) ob.start() try: while True: time.sleep(1) except KeyboardInterrupt: print('stopping...') ob.stop() ob.join()
def __init__(self, holder, configfile, *args, **kwargs): FileSystemEventHandler.__init__(self, *args, **kwargs) self._file = None self._filename = "" self._where = 0 self._satellite = "" self._orbital = None cfg = ConfigParser() cfg.read(configfile) self._coords = cfg.get("local_reception", "coordinates").split(" ") self._coords = [ float(self._coords[0]), float(self._coords[1]), float(self._coords[2]) ] self._station = cfg.get("local_reception", "station") logger.debug("Station " + self._station + " located at: " + str(self._coords)) try: self._tle_files = cfg.get("local_reception", "tle_files") except NoOptionError: self._tle_files = None self._file_pattern = cfg.get("local_reception", "file_pattern") self.scanlines = holder self._warn = True
def init(self): self.gl = mg.create_context() self.vbo = [ ( self.gl.buffer( np.array([-1.0, -1.0, -1.0, +1.0, +1.0, -1.0, +1.0, +1.0]) .astype(np.float32) .tobytes() ), "2f", "in_pos", ) ] self.ibo = self.gl.buffer( np.array([0, 1, 2, 2, 1, 3]).astype(np.int32).tobytes() ) self.recompile() handler = FileSystemEventHandler() handler.on_modified = lambda e: self.set_recompile_flag(True) observer = Observer() observer.schedule(handler, "./gl/") observer.start()
def __init__(self): FileSystemEventHandler.__init__(self) # futureproofing - not need for current version of watchdog self.root = None self.currentdir = None # The actual logdir that we're monitoring self.logfile = None self.observer = None self.observed = None # a watchdog ObservedWatch, or None if polling self.thread = None self.event_queue = [] # For communicating journal entries back to main thread # On startup we might be: # 1) Looking at an old journal file because the game isn't running or the user has exited to the main menu. # 2) Looking at an empty journal (only 'Fileheader') because the user is at the main menu. # 3) In the middle of a 'live' game. # If 1 or 2 a LoadGame event will happen when the game goes live. # If 3 we need to inject a special 'StartUp' event since consumers won't see the LoadGame event. self.live = False self.game_was_running = False # For generation the "ShutDown" event # Context for journal handling self.version = None self.is_beta = False self.mode = None self.group = None self.cmdr = None self.planet = None self.system = None self.station = None self.stationtype = None self.coordinates = None self.systemaddress = None self.started = None # Timestamp of the LoadGame event # Cmdr state shared with EDSM and plugins self.state = { 'Captain' : None, # On a crew 'Cargo' : defaultdict(int), 'Credits' : None, 'FID' : None, # Frontier Cmdr ID 'Horizons' : None, # Does this user have Horizons? 'Loan' : None, 'Raw' : defaultdict(int), 'Manufactured' : defaultdict(int), 'Encoded' : defaultdict(int), 'Engineers' : {}, 'Rank' : {}, 'Reputation' : {}, 'Statistics' : {}, 'Role' : None, # Crew role - None, Idle, FireCon, FighterCon 'Friends' : set(), # Online friends 'ShipID' : None, 'ShipIdent' : None, 'ShipName' : None, 'ShipType' : None, 'HullValue' : None, 'ModulesValue' : None, 'Rebuy' : None, 'Modules' : None, }
def __init__(self, library, path, xbmcif): FileSystemEventHandler.__init__(self) self.library = library self.path = path self.xbmcif = xbmcif self.supported_media = '|' + py2_decode( xbmc.getSupportedMedia(library)) + '|'
def init_gl(self): self.gl = mg.create_context() self.vbo = self.gl.buffer( np.array( [-1.0, -1.0, 0.0, -1.0, +1.0, 0.0, +1.0, -1.0, 0.0, +1.0, +1.0, 0.0] ) .astype(np.float32) .tobytes() ) self.ibo = self.gl.buffer( np.array([0, 1, 2, 2, 1, 3]).astype(np.int32).tobytes() ) self.recompile() width, height = glfw.get_window_size(self.window) self.uniform("u_resolution", vec2(width, height)) self.wire_events() def on_mod(e): self.should_recompile = True handler = FileSystemEventHandler() handler.on_modified = on_mod self.observer = Observer() self.observer.schedule(handler, "./gl/", True) self.observer.start()
def __init__(self, args, callback=None): self._watchdog_observer = None self._path = args.config self._callback = callback self._config = {} # Load from file try: self.load_config_file() except FileNotFoundError: logger.info("No configuration file, creating a new one") self._config = CONF_SCHEMA({}) # Overwrite with command line arguments args_keys = vars(args) for key in args_keys: if self._config.get(key) != args_keys[key]: self._config[key] = args_keys[key] self.save_config_file() self._watchdog_observer = Observer() watchdog_event_handler = FileSystemEventHandler() watchdog_event_handler.on_modified = lambda event: self.load_config_file( ) self._watchdog_observer.schedule(watchdog_event_handler, self._path) self._watchdog_observer.start()
def watch_note(note, handle_func): """watch a single note for changes, call `handle_func` on change""" ob = Observer() handler = FileSystemEventHandler() def handle_event(event): """update the note only if: - the note itself is changed - a referenced asset is changed """ _, filename = os.path.split(event.src_path) # get all absolute paths of referenced images images = [] for img_path in note.images: if not os.path.isabs(img_path): img_path = os.path.join(note.dir, img_path) images.append(img_path) if note.filename == filename or event.src_path in images: handle_func(note) handler.on_any_event = handle_event print('watching {0}...'.format(note.title)) ob.schedule(handler, note.dir, recursive=True) ob.start() try: while True: time.sleep(1) except KeyboardInterrupt: print('stopping...') ob.stop() ob.join()
def track_directories(directories, session, bucket_name): global aws_session, bucket aws_session = session bucket = bucket_name observer = Observer() # Create event handler and set the function to call when event occurs. event_handler = FileSystemEventHandler() event_handler.on_created = upload_file_to_S3 # Schedule the observer to monitor every directory in the config file. for directory in directories: observer.schedule(event_handler, directory, recursive=True) write_to_log('Scheduled observer for ' + directory) # Start the observer. observer.start() try: write_to_log('Beginning to wait for events.') # Constantly wait for events. while True: time.sleep(1) # Stop when user presses Ctrl + C. except KeyboardInterrupt: write_to_log('Stopping observers...') observer.stop() observer.join() write_to_log('Stopped observers.')
def __init__(self, paths, forkloop, minimum_wait=2.0): FileSystemEventHandler.__init__(self) self.forkloop = forkloop self.observers = [] self.paths = paths self.minimum_wait = minimum_wait self.last_event = time.time()
def monitor(self): """Monitor current installation and log any changes""" print("Details at: " + LOGS_DIR + self.type + "-" + self.name + "-monitor.log") logging.basicConfig(filename=LOGS_DIR + self.type + "-" + self.name + "-monitor.log", level=logging.INFO, format='%(asctime)s - %(message)s', datefmt='%d-%m-%Y %H:%M:%S') # Monitor for changes and write details to a log event_handler = LoggingEventHandler() observer = Observer() observer.schedule(event_handler, self.path, recursive=True) observer.start() # Monitor for changes and trigger a event filesystem_event = FileSystemEventHandler() filesystem_event.on_modified = self.on_modified observer.schedule(filesystem_event, self.path, recursive=True) try: while True: time.sleep(1) except KeyboardInterrupt: observer.stop() observer.join()
def __init__(self, paths, forkloop, minimum_wait=2.0): FileSystemEventHandler.__init__(self) self.forkloop = forkloop self.observers = [] self.paths = paths self.minimum_wait = minimum_wait self.last_event = time.time()
def __init__(self, width, height): super(Context, self).__init__() self.recorder = None self.GL = mg.create_context() self.width, self.height = width, height self.screenvbo = self.GL.buffer(reserve=4 * 4 * 4) self.screenibo = self.GL.buffer(reserve=6 * 4) self.screenvbo.bind_to_storage_buffer(0) self.screenibo.bind_to_storage_buffer(1) self.programs = [] self.vertex_arrays = [] self.recompile() def on_mod(e): self._should_recomile = True handler = FileSystemEventHandler() handler.on_modified = on_mod observer = Observer() observer.schedule(handler, "./gl") observer.start()
def __init__(self): FileSystemEventHandler.__init__(self) # futureproofing - not need for current version of watchdog self.root = None self.logdir = self._logdir() self.logfile = None self.observer = None self.thread = None self.callback = None self.last_event = None # for communicating the Jump event
def __init__(self): self.watcher_pid_file = os.path.join(MONITOR_ROOT, "watcher.pid.txt") self.watcher_log_file = os.path.join(MONITOR_ROOT, "watcher.log.txt") self.annex_observer = Observer() self.netcat_queue = [] self.cleanup_upload_lock = False FileSystemEventHandler.__init__(self)
def __init__(self, collectors, terminator, decoder, patterns, observer_class_name): FileSystemEventHandler.__init__(self) FileTrigger.__init__(self, collectors, terminator, decoder) self.input_dirs = [] for pattern in patterns: self.input_dirs.append(os.path.dirname(pattern)) self.patterns = patterns self.new_file = Event() self.observer = self.cases.get(observer_class_name, Observer)()
def on_modified(self, event): ''' @summary: ファイル更新時イベント ファイルのときはインデックス更新 ディレクトリのときはファイルが追加されたときとかそういうイベントなので、無視 ''' if not event.is_directory: self.refresh_file(event.src_path) FileSystemEventHandler.on_created(self, event)
def __init__(self, patterns, observer_class_name="Observer"): FileSystemEventHandler.__init__(self) self.input_dirs = [] for pattern in patterns: self.input_dirs.append(os.path.dirname(pattern)) LOG.debug("watching " + str(os.path.dirname(pattern))) self.patterns = patterns self.new_file = Event() self.observer = self.cases.get(observer_class_name, Observer)()
def __init__(self): FileSystemEventHandler.__init__(self) # futureproofing - not need for current version of watchdog self.root = None self.logdir = self._logdir() self.logfile = None self.logging_enabled = self._logging_enabled self._restart_required = False self.observer = None self.thread = None self.last_event = None # for communicating the Jump event
def on_deleted(self, event): ''' @summary: ファイル削除イベント ''' if event.is_directory: pass else: self.watcher.index.remove([event.src_path]) logger.debug("DELETE %s" % event.src_path) FileSystemEventHandler.on_deleted(self, event)
def on_created(self, event): ''' @summary: 新規作成時イベント 新規ファイルのインデックスを追加する ''' if event.is_directory: self.watcher.analyze_dir(event.src_path, True) else: self.watcher.analyze_file(event.src_path) FileSystemEventHandler.on_created(self, event)
def __init__(self, dirname, record_source, loglevel): FileSystemEventHandler.__init__(self) self.dirname = dirname if not os.path.isdir(self.dirname + constants.TMP_FOLDER): os.mkdir(self.dirname + constants.TMP_FOLDER) self.changes = {} self.just_changed = {} self.valid = re.compile(r'^(\./)?([^/]+/)*(?!\.)[^/]*[^~]$') #PE test this, should work #self.valid = re.compile(r'^(.+/)*[^\./][^/~]*$') self.record_source = record_source self.loglevel = loglevel
def __init__(self, exit, input_directory, output_directory, output_directory_tmp, loop=None, **kwargs): self._exit = exit self._loop = loop self._input_directory = input_directory self._output_directory = (output_directory_tmp, output_directory) logging.info('From directory is ' + input_directory) logging.info('To directory is ' + output_directory) AIOEventHandler.__init__(self, loop) FileSystemEventHandler.__init__(self, **kwargs)
def __init__(self, folder, callback=lambda x: None): self.callback = callback event_handler = FileSystemEventHandler() def handler(e): path = e.src_path if path.endswith('.txt'): self.callback(path, read_text_file(path)) # this happens also when file is created event_handler.on_modified = handler self.observer = Observer() self.observer.schedule(event_handler, folder)
def start(self): from watchdog.observers import Observer from watchdog.events import FileSystemEventHandler handler = FileSystemEventHandler() handler.on_modified = self.compile_sass watch = Observer() watch.schedule(handler, self.assets_dir, recursive=True) watch.start() app.logger.info('Watching \'{}\' for changes'.format(self.assets_dir))
def __init__(self): FileSystemEventHandler.__init__(self) # futureproofing - not need for current version of watchdog self.root = None self.logdir = self._logdir() # E:D client's default Logs directory, or None if not found self.currentdir = None # The actual logdir that we're monitoring self.logfile = None self.observer = None self.observed = None self.thread = None self.callbacks = { 'Jump': None, 'Dock': None } self.last_event = None # for communicating the Jump event
def __init__(self, options): # print options # Store the command line args self.options = options self.channel = Channel.objects.get(slug=self.options['channel_name']) # Init ourselves some redis pool = redis.ConnectionPool(host='localhost', port=6379, db=self.channel.redis_db) r = redis.Redis(connection_pool=pool) self.pipe = r.pipeline() self.redis_index = 0 # If the overwrite flag is set, flush the redis db, # set the channel line count to 0, and set the date # context to the channel start date, else grab the latest # date from the scores if self.options['overwrite']: r.flushdb() self.channel.set_line_count(0) self.date = self.channel.start_date else: self.date = self.channel.get_latest_date() # Define the nick handling members self.nicks = dict() nick_regex_string = '[a-zA-Z0-9_-\{\}\^\`\|]+' self.nick_regex_strings = [ '<(?P<nick>%s)>' % nick_regex_string, 'Action: (?P<nick>%s) ' % nick_regex_string, 'Nick change: (?P<nick>%s) ' % nick_regex_string, 'Topic changed on [#&][[a-zA-Z0-9]+ by (?P<nick>%s)\!' % nick_regex_string, '%s kicked from [#&][[a-zA-Z0-9]+ by (?P<nick>%s)' % (nick_regex_string, nick_regex_string), '(?P<nick>%s) \(.*\) [left|joined]' % nick_regex_string, '[#&][[a-zA-Z0-9]+: mode change \'.*\' by (?P<nick>%s)\!' % nick_regex_string ] #Grab a list of files in the target directory, sort and stick in a deque for optimized access (lists are slow) self.dir = deque() for f in sorted(filter(lambda x: self.options['filter_string'] in x, os.listdir(self.options['path']))): self.dir.append('%s%s' % (self.options['path'], f)) # Open the first file in the queue self.file = open(self.dir.popleft(), 'r') # Set the initial file position self.where = self.file.tell() # Run the initial feed of the logs self.ReadLog() FileSystemEventHandler.__init__(self)
def __init__(self, cfg_path=None, sharing_path=None): FileSystemEventHandler.__init__(self) # Just Initialize variable the Daemon.start() do the other things self.daemon_state = 'down' # TODO implement the daemon state (disconnected, connected, syncronizing, ready...) self.running = 0 self.client_snapshot = {} # EXAMPLE {'<filepath1>: ['<timestamp>', '<md5>', '<filepath2>: ...} self.local_dir_state = {} # EXAMPLE {'last_timestamp': '<timestamp>', 'global_md5': '<md5>'} self.listener_socket = None self.observer = None self.cfg = self._load_cfg(cfg_path, sharing_path) self.password = self._load_pass() self._init_sharing_path(sharing_path) self.conn_mng = ConnectionManager(self.cfg)
def __init__(self, monitor_dir, config, archive=False, initial_scan=False, archive_suffix="_orig.pdf"): FileSystemEventHandler.__init__(self) self.monitor_dir = monitor_dir self.archive_suffix = archive_suffix self.archive = archive if not config: config = {} # Scan initial folder if initial_scan: self.scan_folder() self.scan_interval = config.get('scan_interval', 3) # If no updates in 3 seconds (or user specified option in config file) process file
def __init__(self, paper_filename, publish_url, paper_id): FileSystemEventHandler.__init__(self) # super init self.paper_filename = paper_filename self.is_pdf = paper_filename.endswith('pdf') self.publish_url = publish_url self.paper_id = paper_id self.reset_stats() logging.info( "Creating a GamificationHandler with paper: " + paper_filename + " publish_url: " + publish_url + " and paper id: " + paper_id )
def start_fs_loop(): init() try: os.makedirs("albums") except: None ev_handler = FileSystemEventHandler() ev_handler.dispatch = handle_fs_events event_handler = LoggingEventHandler() observer = Observer() observer.schedule(ev_handler, "albums/", recursive=True) observer.start() try: while True: time.sleep(1) except KeyboardInterrupt: observer.stop() observer.join()
def __init__(self): # Grab a list of files in the target directory, sort and stick in a deque for optimized access (lists are slow) self.dir = deque() for f in sorted(filter(lambda x: args.filter_string in x, os.listdir(args.path))): self.dir.append('%s%s' % (args.path, f)) # Open the first file in the queue self.file = open(self.dir.popleft(), 'r') # Init ourselves some redis self.r = redis.Redis(host='localhost', port=6379, db=args.db_index) self.redis_index = 0 # Set the initial file position self.where = self.file.tell() # Run the initial feed of the logs self.ReadLog() FileSystemEventHandler.__init__(self)