def block_until_synchronised_files_data_source_started(source: SynchronisedFilesDataSource): """ Blocks until the given synchronised files data source has started to notice changes in the file system (may be a few milliseconds after it has been started). :param source: the synchronised files data source that has been started """ blocked = True def unblock(*args): nonlocal blocked blocked = False event_handler = FileSystemEventHandler() event_handler.on_modified = unblock source._observer.schedule(event_handler, source._directory_location, recursive=True) temp_file_name = ".temp_%s" % block_until_synchronised_files_data_source_started.__name__ temp_file_path = os.path.join(source._directory_location, temp_file_name) i = 0 while blocked: with open(temp_file_path, 'a') as file: file.write(str(i)) sleep(10 / 1000) i += 1
def initializeGL(self): self.gl = mg.create_context() self.vertices = self.gl.buffer( np.array( [ (-1.0, -1.0, 0.0, 1.0), (+1.0, -1.0, 0.0, 1.0), (-1.0, +1.0, 0.0, 1.0), (+1.0, +1.0, 0.0, 1.0), ], dtype=np.float32, ) ) self.indices = self.gl.buffer(np.array([0, 1, 2, 2, 1, 3], dtype=np.int32)) self.reload_textures() self.recompile_shaders() handler_gl = FileSystemEventHandler() handler_gl.on_modified = self.on_gl_src_modified handler_resources = FileSystemEventHandler() handler_resources.on_modified = self.on_resources_modified oberver = Observer() oberver.schedule(handler_gl, "./gl", True) oberver.schedule(handler_resources, "./resources", True) oberver.start()
def on_modified(self, event): FileSystemEventHandler.on_modified(self, event) src_relpath = os.path.abspath(event.src_path) if os.path.isdir(event.src_path): self._onchange(src_relpath, FsProvider.DIRECTORY, self.sender.get_uid()) else: self._onchange(src_relpath, FsProvider.FILE, self.sender.get_uid())
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 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, 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 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, 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 start(self): if not glfw.init(): return glfw.window_hint(glfw.FLOATING, glfw.TRUE) glfw.window_hint(glfw.RESIZABLE, glfw.TRUE) self.u_width, self.u_height = 400, 400 self.u_volume_size = (64, 64, 64) self.window = glfw.create_window(self.u_width, self.u_height, "pyGLFW window", None, None) if not self.window: glfw.terminate() return glfw.make_context_current(self.window) self.init() self.should_rebuild = False glfw.set_framebuffer_size_callback(self.window, self.on_resize_fb) glfw.set_key_callback(self.window, self.on_key) handler = FileSystemEventHandler() handler.on_modified = lambda e: self.set_rebuild(True) observer = Observer() observer.schedule(handler, "./gl") observer.start()
def __init__(self, window): super().__init__() self.window = window self.gl = mg.create_context() imgui.create_context() self.imgui_renderer = ModernGLGLFWRenderer( ctx=self.gl, display_size=glfw.get_window_size(window)) self.imgui_renderer.wire_events(self.gl, window) self.reload() def onmod(e): self.should_reload = True handler = FileSystemEventHandler() handler.on_modified = onmod observer = Observer() observer.schedule(handler, "./gl", True) observer.start() self.input_text = "" self.is_press = False self.prev_cursor = (0, 0) self.imgui_renderer.on_mouse_button = self.on_mouse_button self.imgui_renderer.on_cursor_pos = self.on_cursor_pos self.imgui_renderer.on_key = self.on_key
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 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, 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 _watch(self, target): queue = self._collect(target) observer = Observer() def on_created(event): nonlocal queue for matcher in self.matchers: matcher.process_file(event.src_path) queue = self._collect(target) def on_modified(event): rule = self.lookup_rule(event.src_path) if isinstance(rule, SourceFileRule): self._invoke_queue(queue) handler = FileSystemEventHandler() handler.on_created = on_created handler.on_modified = on_modified observer.schedule(handler, '.', recursive=True) self._invoke_queue(queue) observer.start() observer.join() return 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, 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, 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): self.gl = mg.create_context() self.should_compile = True h = FileSystemEventHandler() h.on_modified = self.on_gl_mod o = Observer() o.schedule(h, "./gl", True) o.start()
def init_watchdog(self): def on_modified(e): self.should_reload_shaders = True handler = FileSystemEventHandler() handler.on_modified = on_modified observer = Observer() observer.schedule(handler, "./gl", True) observer.start()
def init(self): # init gl self.gl = mg.create_context() self.compile_shaders() handler = FileSystemEventHandler() handler.on_modified = self.on_modified observer = Observer() observer.schedule(handler, "./gl/", True) observer.start()
def initializeGL(self): self.gl = mg.create_context(require=460) self.compile_shaders() self.load_textures() def on_modified(event): self._need_compile = True def on_modified_textures(event): self._need_reload_texture = True handler = FileSystemEventHandler() handler.on_modified = on_modified handler_texture = FileSystemEventHandler() handler_texture.on_modified = on_modified_textures observer = Observer() observer.schedule(handler, "./gl", True) observer.schedule(handler_texture, "./resource", True) observer.start()
def watch(directory=os.getcwd(), silent=False): # Since watchdog sometimes fires events multiple times, we'll only complie each path once per cycle compiled_this_cycle = {0} # Event which dispatches when a file or directory is modified def on_modified(event): # Ignore directories if event.is_directory: return path = event.src_path # Only compile .mcfunction files file_extension = os.path.splitext(path)[1] if file_extension != '.mcfunction': return # Check if this file has been compiled this cycle if path in compiled_this_cycle: return if not silent: print( f'File \'{os.path.basename(path)}\' was modified, compiling if necessary...' ) compiled_this_cycle.add(path) # Wait for the text editors to finish writing to the file sleep(0.5) compile_function(path) event_handler = FileSystemEventHandler() event_handler.on_modified = on_modified observer = Observer() observer.schedule(event_handler, directory, recursive=True) print( f'Starting to watch for changes in \'{directory}\'.\nPress CTRL/CMD + C to terminate the process.' ) observer.start() # Watch loop try: while True: sleep(3) # Clear the compile list every cycle compiled_this_cycle.clear() # Terminate the process except KeyboardInterrupt: print('Killing the process...') observer.stop() observer.join()
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, window): super(RenderClient, self).__init__(window) self.gl = mg.create_context() self.compile() hand = FileSystemEventHandler() hand.on_modified = lambda e: self.set_need_compile() observer = Observer() observer.schedule(hand, "./gl", True) observer.start()
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 init(self): self.gl = mg.create_context() self.compile() def set_need_compile(): self._need_compile = True handler = FileSystemEventHandler() handler.on_modified = lambda e: set_need_compile() observer = Observer() observer.schedule(handler, "./gl", True) observer.start()
def initializeGL(self): self.gl = mg.create_context() self.compile() def onmod(e): self.need_compile = True handler = FileSystemEventHandler() handler.on_modified = onmod observer = Observer() observer.schedule(handler, "./gl", True) observer.start()
def build_vao(self): self.rebuild_vao() def on_mod(e=None): self.require_rebuild = True if self.auto_rebuild: handler = FileSystemEventHandler() handler.on_modified = on_mod observer = Observer() observer.schedule(handler, "./gl/") observer.start()
def init(self): self.gl = mg.create_context() self.compile() def on_mod(e): self.needcompile = True h = FileSystemEventHandler() h.on_modified = on_mod o = Observer() o.schedule(h, "./gl/", True) o.start()
def init(self): self.gl = mg.create_context() self.build_vao() def on_mod(e): self.should_compile = True handler = FileSystemEventHandler() handler.on_modified = on_mod ob = Observer() ob.schedule(handler, "./gl/", True) ob.start()
def init(self): self.gl = mg.create_context() self.compile_shaders() def on_mod(e): self.should_compile_shaders = True handler = FileSystemEventHandler() handler.on_modified = on_mod observer = Observer() observer.schedule(handler, "./gl", True) observer.start()
def __init__(self, window): super(RenderClient, self).__init__(window) self.gl = mg.create_context() self._compile() def on_mod(e): self._need_compile = True hand = FileSystemEventHandler() hand.on_modified = on_mod o = Observer() o.schedule(hand, "./gl/", True) o.start()
path = event.src_path change_type = event.event_type class_name = event.__class__.__name__ if re.match('^Dir', class_name): if DEBUG: print ' - skipped dir |%s|' %(path) return return process_change(change_type, path) if __name__ == '__main__': OBSERVER = Observer() EVENT_HANDLER = FileSystemEventHandler() EVENT_HANDLER.on_created = on_changed EVENT_HANDLER.on_modified = on_changed EVENT_HANDLER.on_deleted = on_changed ## The following event types are not supported # EVENT_HANDLER.on_moved = on_changed # EVENT_HANDLER.on_any_event = on_changed OBSERVER.schedule(EVENT_HANDLER, LOCAL_PATH, recursive=True) OBSERVER.start() try: while True: time.sleep(10) except KeyboardInterrupt: OBSERVER.stop()
def on_modified(self, event): FileSystemEventHandler.on_modified(self, event) self.process_event(event.src_path) return True
def copy_resource_to_server(event): """Copy SRC_FILE to DEST_FILE""" try: if event.src_path == SRC_FILE: shutil.copyfile(SRC_FILE, DEST_FILE) except Exception as ex: print type(ex) print ex event_handler = FileSystemEventHandler() event_handler.on_created = copy_resource_to_server event_handler.on_modified = copy_resource_to_server observer = Observer() observer.schedule(event_handler, SRC_DIR, recursive=False) observer.start() try: while True: time.sleep(1) except KeyboardInterrupt: observer.stop() observer.join()