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()
