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()
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 initializeGL(self):
self.gl = mg.create_context()
self._compile_shaders()
def onmod(e):
self._need_compile = True
handler = FileSystemEventHandler()
handler.on_modified = onmod
observer = Observer()
observer.schedule(handler, "./gl", True)
observer.schedule(handler, "./textures", True)
observer.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()
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, user, password, server):
self.neo = Neo4j(user=user, password=password, server=server)
self.tenant = None
self.data_path = Path.home() / ".stormspotter/input"
self.processed_path = Path.home() / ".stormspotter/processed"
self.observer = Observer()
self.event_handler = FileSystemEventHandler()
self.event_handler.on_created = self.on_created
self.observer.schedule(self.event_handler, str(self.data_path))
self.observer.start()
self.processExistingFiles()
def __init__(self, window):
super(RenderClient, self).__init__(window)
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 __init__(self, working_dir='.', watched_dirs=['.']):
"""
:param watched_dirs: Directories to watch for changes.
:type watched_dirs: list of str
"""
self._working_dir = working_dir
self._watched_dirs = watched_dirs
self._started = False
self._observer = Observer()
self._handler = FileSystemEventHandler()
for path in watched_dirs:
path = os.path.abspath(os.path.join(working_dir, path))
self._observer.schedule(self._handler, path, recursive=True)
def __init__(self, window):
super(Client, self).__init__()
self.window = window
Client.gl = Client.gl or mg.create_context()
self.compile_shaders()
glfw.set_key_callback(window, self.on_key)
h = FileSystemEventHandler()
h.on_modified = self.on_modified
o = Observer()
o.schedule(h, "./gl/", True)
o.start()
def initializeGL(self):
self.gl = mg.create_context(require=460)
self.compile()
self.load_textures()
def on_modified(e):
self.need_compile = True
handler = FileSystemEventHandler()
handler.on_modified = on_modified
observer = Observer()
observer.schedule(handler, "./gl", True)
observer.start()
def __init__(self, window):
super().__init__()
self.window = window
self.gl = mg.create_context()
self.reload()
def on_modified(e):
self.should_compile = True
handler = FileSystemEventHandler()
handler.on_modified = on_modified
observer = Observer(handler, "./gl/", True)
observer.start()
def __init__(self, window):
super(Client, self).__init__()
self.window = window
self.gl = mg.create_context()
self._compile_shader()
def onmod(e):
self._should_compile = True
handler = FileSystemEventHandler()
handler.on_modified = onmod
observer = Observer()
observer.schedule(handler, "./gl/", True)
observer.start()
def fileWatcher():
observer = Observer()
eventHandler = FileSystemEventHandler()
eventHandler.on_created = fileSystemEventHandler
#eventHandler.on_modified = fileSystemEventHandler
pName=pkg.components.processComponentMap["processName"]
observer.schedule(eventHandler, pkg.components.processComponentMap["rules"][pName]["directory"], recursive=True)
observer.start()
log.info("File watcher started")
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def initializeGL(self):
self.gl = mg.create_context()
self.u_res = uvec2(512, 512)
self.b_screen_draw = self.gl.buffer(reserve=512 * 512 * 4 * 4)
self.b_screen_draw.bind_to_storage_buffer(1)
self.compile()
def on_modified(e):
self.need_compile = True
h = FileSystemEventHandler()
h.on_modified = on_modified
o = Observer()
o.schedule(h, "./", True)
o.start()
def __init__(self, window):
super().__init__()
self.window = window
self.gl = mg.create_context()
self.meshes = [Quad(self.gl, window, "./gl/quad.vs", "./gl/quad.fs")]
handler = FileSystemEventHandler()
handler.on_modified = self.on_watch_gl_update
observer = Observer()
observer.schedule(handler, "./gl", True)
observer.start()
self.writer = ii.get_writer("./capture.mp4", fps=60)
self.color_buffer = self.gl.texture((512, 512), 4, dtype="f1")
self.frame = self.gl.framebuffer([self.color_buffer])
def __init__(self, proc_dir=None, event_callback=None,):
self.log = logging.getLogger(__file__)
self.event_callback = event_callback
self.started = False
if proc_dir is None:
self.proc_dir = os.path.abspath(os.environ.get("MILK_PROC_DIR", "/milk/proc"))
else:
self.proc_dir = os.path.abspath(proc_dir)
self.log.debug("Milk file tracker set to track {}.".format(self.proc_dir))
self.files = set()
self.event_handler = FileSystemEventHandler()
self.event_handler.on_created = self.file_created_action
self.event_handler.on_deleted = self.file_deleted_action
self.observer = Observer()
self.observer.schedule(self.event_handler, self.proc_dir, recursive=False)
def watch_path(path, func, poll_time=0.5, name=None, skip_first=False):
"""
Watch path and execute the given function everytime a file changes.
"""
import time
from watchdog.observers import Observer
from watchdog.events import (
FileSystemEventHandler,
FileCreatedEvent,
FileDeletedEvent,
FileModifiedEvent,
FileMovedEvent,
)
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()
observer = Observer()
handler = FileSystemEventHandler()
handler.dispatch = dispatch
observer.schedule(handler, path, recursive=True)
observer.start()
name = name or func.__name__
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 __init__(self, **kwargs):
super(FilesContent, self).__init__(**kwargs)
Clock.schedule_interval(self.collect_meta_data, 0.1)
#if octoprint has changed files then update them
session_saver.save_variable('file_callback', self.call_to_update)
session_saver.save_variable('usb_mounted', False)
#schedule directory observer http://pythonhosted.org/watchdog/api.html#watchdog.events.FileSystemEventHandler
self.dir_observe = Observer()
self.callback = FileSystemEventHandler()
self.callback.on_any_event = self.on_any_event
if sys.platform != "win32":
self.dir_observe.schedule(self.callback, "/dev", recursive=True)
self.dir_observe.start()
self.update_files()
def __init__(self):
try:
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
self.observer = Observer()
self.monitor = FileSystemEventHandler()
self.observer.start()
except ImportError:
logger.error(
_('Missing dependency: python "{}" package').format(
'watchdog'))
logger.info(
_('Monitoring of changes to reload files automatically is not available'
))
def main():
event_handler = FileSystemEventHandler()
event_handler.on_created = on_change
event_handler.on_moved = on_change
event_handler.on_modified = on_change
observer = Observer()
observer.schedule(event_handler, str(src / Path("res")), recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def init(self):
self.gl = mg.create_context()
gl = self.gl
self.vbo = gl.buffer(
np.array([-1.0, -1.0, -1.0, +1.0, +1.0, -1.0, +1.0,
+1.0]).astype(np.float32).tobytes())
self.ibo = gl.buffer(
np.array([0, 1, 2, 2, 1, 3]).astype(np.int32).tobytes())
self.recompile(gl)
self.should_recompile = False
handler = FileSystemEventHandler()
handler.on_modified = lambda e: self.set_recompile_flag(True)
watcher = Observer()
watcher.schedule(handler, "./gl")
watcher.start()
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()
def on_modified(e):
self.should_compile = True
h = FileSystemEventHandler()
h.on_modified = on_modified
o = Observer()
o.schedule(h, "./gl", True)
o.start()
def __init__(self, window):
super(Client, self).__init__()
self.window = window
self.gl = mg.create_context()
self.volume_res = ivec3(128, 128, 128)
self.compute_group_res = self.volume_res / 8
self.compile()
# start shader code observer
h = FileSystemEventHandler()
h.on_modified = self.on_modified
o = Observer()
o.schedule(h, "./gl/", True)
o.start()
def __init__(self, hplayer):
# Interface settings
super(KeyboardInterface, self).__init__(hplayer, "Keyboard")
# keyboard connection watchdog
event_handler = FileSystemEventHandler()
event_handler.on_created = self.bind
event_handler.on_deleted = self.unbind
self.observer = Observer()
self.observer.schedule(event_handler, '/dev/input/', recursive=False)
self.observer.start()
self.remote = None
self.holdDebounce = 5
self.bind(self.detect())
def __init__(self, window):
super().__init__()
self.window = window
self.gl = mg.create_context()
assert self.gl, "failed to create gl context"
self.compile()
def on_mod(e):
self._need_compile = True
handler = FileSystemEventHandler()
handler.on_modified = on_mod
observer = Observer()
observer.schedule(handler, "./gl", True)
observer.start()
def __init__(self, module_pkgname):
super().__init__()
self._module_pkgname = module_pkgname
self._dirs_to_watch = set()
self._files_to_watch = set()
self._modules = set()
self._event_handler = FileSystemEventHandler()
self._event_handler.on_any_event = self._on_any_event
self._observer = Observer()
self._observer.start()
self._timer = None
self._lock = QtCore.QMutex()
self._query_count = 0
self._query_count_cond = QtCore.QWaitCondition()
self._reloading = False
self._reloading_cond = QtCore.QWaitCondition()
def watch(self):
handler = FileSystemEventHandler()
handler.on_modified = lambda e: self.set_dirty()
observer = Observer()
observer.schedule(handler, "./gl")
observer.start()
self.execute()
while True:
if not self._isdirty:
time.sleep(0.01)
continue
if self.execute():
break
print("exit")
def __init__(self, log, machine, log_file):
self.__log = log
self.__id = machine['id']
self.__name = machine['name']
self.__ip = machine['ip']
self.__log_file = log_file
self.__orig_file_content = ""
self.__event_id = 0
self.__db_update_lines = 0
# start observer
self.__event_handler = FileSystemEventHandler()
self.__event_handler.on_modified = self.__on_modified
self.__observer = PollingObserver()
self.__observer.schedule(self.__event_handler, path=self.__log_file)
self.__observer.start()
self.__log.info(f"laser initialized for {self.__name} [{self.__ip}]")
def __init__(self, window, width, height):
super(Client, self).__init__()
self.window = window
self.width, self.height = width, height
self.gl = mg.create_context()
MSAA = 2
self.gb_color = self.gl.texture((width * MSAA, height * MSAA), 4)
self.gbuffer = self.gl.framebuffer([self.gb_color])
self.init_input()
self.compile_scene()
h = FileSystemEventHandler()
h.on_modified = self.on_modified
o = Observer()
o.schedule(h, "./gl/", True)
o.start()
def __init__(self, window, width, height):
super(Render, self).__init__()
self.window = window
self.width, self.height = width, height
self.gl = mg.create_context()
self.build_quad()
self.compile()
def onmod(e):
self.need_compile = True
h = FileSystemEventHandler()
h.on_modified = onmod
ob = Observer()
ob.schedule(h, "./gl/", True)
ob.start()
