def __init__(self, parentWidget=None):
super().__init__(parentWidget)
self.ui = UiTargetClass()
self.ui.setupUi(self)
self.fileChanged.connect(self._fileChanged, QtCore.Qt.QueuedConnection)
self.ui.autoScrollCB.stateChanged.connect(self._autoScrollChanged)
self.ui.autoScrollCB.setChecked(True)
self.ui.splitByThredCB.stateChanged.connect(self._splitThreadsChanged)
# self.ui.splitByThredCB.setChecked( True )
self.logFile = get_logging_output_file()
## prevents infinite feedback loop
logging.getLogger('watchdog.observers.inotify_buffer').setLevel(
logging.INFO)
event_handler = PatternMatchingEventHandler(patterns=[self.logFile])
event_handler.on_any_event = self._logFileCallback
dirPath = os.path.dirname(self.logFile)
self.observer = Observer()
self.observer.schedule(event_handler, path=dirPath, recursive=False)
self.updateLogView()
self.observer.start()
def __init__(self, parent, path):
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
self.parent = parent
my_event_handler = PatternMatchingEventHandler(patterns,
ignore_patterns,
ignore_directories,
case_sensitive)
def on_any_event(event):
parent.ftpListUpdate()
my_event_handler.on_any_event = on_any_event
go_recursively = False
my_observer = Observer()
my_observer.schedule(my_event_handler, path, recursive=go_recursively)
my_observer.start()
while self.parent.keepWatching():
time.sleep(1)
my_observer.stop()
my_observer.join()
def add(self, path):
"""
Set root directories with attached watchdogs
"""
# filter .tmp changes
def onChange(e):
if not e.src_path.endswith('.tmp'):
if not e.src_path.endswith('project.json'):
self.emit('file-changed', e)
if not isinstance(path, list):
path = [path]
for p in path:
if not os.path.isdir(p):
self.log("Basepath "+p+" not found... ignoring")
continue
# p = '/tmp'+os.path.abspath(p)
# pathlib.Path(p).mkdir(parents=True, exist_ok=True)
else:
self.log("Adding "+p+" as root paths")
self.root_paths.append(p)
handler = PatternMatchingEventHandler("*", None, False, True)
handler.on_any_event = onChange
my_observer = Observer()
my_observer.schedule(handler, p, recursive=True)
my_observer.start()
self.pathObservers.append(my_observer)
self.refresh()
def start_params_monitor():
load_values_from_file()
event_handler = PatternMatchingEventHandler(patterns=["*.properties", "*.profile"],
ignore_patterns=[],
ignore_directories=True)
event_handler.on_any_event = on_any_event
observer = Observer()
observer.schedule(event_handler, '.', recursive=False)
observer.start()
def launch(roots, watch, debounce):
debounce = datetime.timedelta(milliseconds=debounce)
collections = collect_mappings(map(find_collections, roots))
log.msg("collections found", collections=collections)
def install_all():
log.msg("init", dir_count=len(collections))
for c in collections.items():
install(*c)
if watch:
to_process = {}
def handle_change(event):
event_path = event.src_path
path = next((path for path in collections.keys()
if event_path.startswith(path)))
log.msg("change event",
trigger=event.src_path,
collection_path=path)
to_process[path] = datetime.datetime.now()
handler = PatternMatchingEventHandler(patterns="*",
ignore_patterns="",
ignore_directories=False,
case_sensitive=True)
handler.on_any_event = handle_change
my_observer = Observer()
for d in collections.keys():
my_observer.schedule(handler, path=d, recursive=True)
my_observer.start()
log.msg("observation", op="start", dir_count=len(collections))
try:
while True:
time.sleep(1)
now = datetime.datetime.now()
to_remove = []
for k, v in to_process.copy().items():
if now > v + debounce:
install(k, collections[k])
to_remove.append(k)
for k in to_remove:
del to_process[k]
except KeyboardInterrupt:
log.msg("observation", op="stop")
my_observer.stop()
my_observer.join()
else:
install_all()
def init_watchdog(self):
ev_handler = PatternMatchingEventHandler(['*.waypoints', '*.poly'],
ignore_directories=True)
ev_handler.on_any_event = self.on_any_file_event
if self.mission_folder is None:
self.mission_folder = getcwd()
self.ev_observer.schedule(ev_handler,
self.mission_folder,
recursive=False)
self.ev_observer.start()
pass
def start_watchdog(self):
def on_any_event(_):
self.reset_controllers_flag = True
event_handler = PatternMatchingEventHandler(patterns=["*.py"],
ignore_patterns=[],
ignore_directories=True)
event_handler.on_any_event = on_any_event
path = CONTROLLERS_DIR
self.observer = Observer()
self.observer.schedule(event_handler, path, recursive=True)
self.observer.start()
def main():
"""CLI Command to execute the provided script with pymon"""
# CLI Argument Parser
parser = argparse.ArgumentParser(
prog="pymon",
description="Executes the provided script with pymon"
)
# Adding arguments to the command
parser.add_argument("filename", type=str, help="The file to execute with pymon", metavar="filename")
parser.add_argument("--force-kill", action="store_true", default=False, help="Force kills the file instead of terminating it", dest="force_kill")
# Fetch arguments
arguments = parser.parse_args()
global process
event_handler = PatternMatchingEventHandler(patterns=["*.py"])
def handle_event(event):
global process
print(Fore.GREEN + "[pymon] restarting due to changes..." + Style.RESET_ALL)
if arguments.force_kill:
process.kill()
else:
process.terminate()
process = subprocess.Popen([sys.executable, arguments.filename])
event_handler.on_any_event = handle_event
observer = Observer()
observer.schedule(event_handler, os.getcwd(), recursive=True)
observer.start()
print(Fore.YELLOW + Style.BRIGHT + "\n[pymon] watching directory" + Style.RESET_ALL)
process = subprocess.Popen([sys.executable, arguments.filename])
print(Fore.GREEN + f"[pymon] starting {arguments.filename}" + Style.RESET_ALL)
try:
while True:
time.sleep(2)
except KeyboardInterrupt:
observer.stop()
observer.join()
def run(application_path: 'the path to the application to run',
reloader: 'reload the application on changes' = False,
workers: 'the number of asynchronous tasks to run' = 1,
debug: 'enable debug mode' = False):
"""Import and run an application."""
import_path, app = _import_application(application_path)
if reloader:
# If the reloader is requested, create threads for running the
# application and watching the file system for changes
print('Running {!r} with reloader...'.format(app))
# Find the root of the application and watch for changes
watchdir = os.path.abspath(import_module(import_path).__file__)
for _ in import_path.split('.'):
watchdir = os.path.dirname(watchdir)
# Create observer and runner threads
observer = Observer()
loop = asyncio.new_event_loop()
runner = Thread(
target=app.run_forever,
kwargs={
'num_workers': workers,
'loop': loop
},
)
# This function is called by watchdog event handler when changes
# are detected by the observers
def restart_process(event):
"""Restart the process in-place."""
os.execv(sys.executable, [sys.executable] + sys.argv[:])
# Create the handler and watch the files
handler = PatternMatchingEventHandler(
patterns=['*.py', '*.ini'],
ignore_directories=True,
)
handler.on_any_event = restart_process
observer.schedule(handler, watchdir, recursive=True)
# Start running everything
runner.start()
observer.start()
else:
# If the reloader is not needed, avoid the overhead
print('Running {!r} forever...'.format(app))
app.run_forever(num_workers=workers)
def watcher(self):
def onchange(e):
self.regieinterface.log('project updated ! pushing it...')
self.sendBuffer.put(('data', self.projectData()))
handler = PatternMatchingEventHandler("*/project.json", None, False,
True)
handler.on_any_event = onchange
self.projectObserver = Observer()
self.projectObserver.schedule(handler,
os.path.dirname(self.projectPath()))
try:
self.projectObserver.start()
except:
self.regieinterface.log('project.json not found')
def run(application_path: 'the path to the application to run',
reloader: 'reload the application on changes' = False,
workers: 'the number of asynchronous tasks to run' = 1,
debug: 'enable debug mode' = False):
"""Import and run an application."""
import_path, app = _import_application(application_path)
if reloader:
# If the reloader is requested, create threads for running the
# application and watching the file system for changes
print('Running {!r} with reloader...'.format(app))
# Find the root of the application and watch for changes
watchdir = os.path.abspath(import_module(import_path).__file__)
for _ in import_path.split('.'):
watchdir = os.path.dirname(watchdir)
# Create observer and runner threads
observer = Observer()
loop = asyncio.new_event_loop()
runner = Thread(
target=app.run_forever,
kwargs={'num_workers': workers, 'loop': loop},
)
# This function is called by watchdog event handler when changes
# are detected by the observers
def restart_process(event):
"""Restart the process in-place."""
os.execv(sys.executable, [sys.executable] + sys.argv[:])
# Create the handler and watch the files
handler = PatternMatchingEventHandler(
patterns=['*.py', '*.ini'],
ignore_directories=True,
)
handler.on_any_event = restart_process
observer.schedule(handler, watchdir, recursive=True)
# Start running everything
runner.start()
observer.start()
else:
# If the reloader is not needed, avoid the overhead
print('Running {!r} forever...'.format(app))
app.run_forever(num_workers=workers)
def _create_handler(callback):
"""Wrapper for the watchdog EventHandler to store file paths in a set"""
bmp_paths = set()
def on_created(e):
bmp_paths.add(e.src_path)
callback(bmp_paths)
def on_deleted(e):
bmp_paths.discard(e.src_path)
event_handler = PatternMatchingEventHandler(patterns=["*.bmp"],
ignore_directories=True,
case_sensitive=False)
event_handler.on_any_event = lambda e: logging.debug(e.src_path)
event_handler.on_created = on_created
event_handler.on_deleted = on_deleted
return event_handler
def le_start():
if DOMAIN_DIR and WATCH:
event_handler = PatternMatchingEventHandler("*.(yml|yaml)", "", ignore_directories=True, case_sensitive=False)
event_handler.on_any_event = lambda event: le_run()
obs = Observer()
obs.schedule(event_handler, DOMAIN_DIR)
obs.start()
try:
while True:
le_run()
if ONCE:
break
time.sleep(60*CHECK_FREQ)
except KeyboardInterrupt:
pass
finally:
if DOMAIN_DIR and WATCH:
obs.stop()
obs.join()
def _loop():
try:
if name is not None:
print("Watching '{}'".format(name))
handler = PatternMatchingEventHandler(patterns=include,
ignore_patterns=exclude,
case_sensitive=True)
handler.on_any_event = _update
observer = Observer()
observer.schedule(handler, folder, recursive=True)
observer.start()
while not stop.is_set():
stop.wait(1)
if _test():
state.last_action = time.clock()
execute(command, name)
if name is not None:
print("Unwatching '{}'".format(name))
observer.stop()
observer.join()
finally:
done.set()
def stage_scenarios(self):
if self.options.follow:
watch_dir = os.path.realpath(self.watch_dir)
else:
watch_dir = self.watch_dir
for rules in self.scenarios:
event_handler = PatternMatchingEventHandler(patterns=rules.pattern,
ignore_directories=self.options.files)
# log_handler = self.PatternMatchingLoggingEventHandler(patterns=rules.pattern,
# ignore_directories=self.options.files,
# rule_id=rules.number,
# action=rules.actions,
# log_dir=self.dirwatch_dir)
cmd_handler = self.EogShellCommandTrick(shell_command=rules.command,
)
if rules.action == 'update': # create or modified
event_handler.on_modified = cmd_handler.on_any_event
event_handler.on_created = cmd_handler.on_any_event
# log_handler.on_modified = log_handler.append_log
# log_handler.on_created = log_handler.append_log
elif rules.action == 'created':
event_handler.on_created = cmd_handler.on_any_event
# log_handler.on_created = log_handler.append_log
elif rules.action == 'modified':
event_handler.on_modified = cmd_handler.on_any_event
# log_handler.on_modified = log_handler.append_log
elif rules.action == 'deleted':
event_handler.on_deleted = cmd_handler.on_any_event
# log_handler.on_deleted = log_handler.append_log
elif rules.action == 'existing': # this is not a exact mapping
event_handler.on_any_event = cmd_handler.on_any_event
# log_handler.on_any_event = log_handler.append_log
self.observer.schedule(event_handler,
watch_dir,
recursive=self.options.recursive)
def create_observer(config):
patterns = '*'
ignore_patterns = ''
ignore_directories = ''
fileChangeHandler = PatternMatchingEventHandler(
patterns = patterns, # watched patterns
ignore_patterns = ignore_patterns, # ignored patterns
ignore_directories = ignore_directories, # ignored directories
case_sensitive = True
)
def on_change(event, config=config):
scss_dir = config['scss_dir']
file_tree = get_include_paths(scss_dir)
raw_scss = get_raw_scss(file_tree, scss_dir)
write_css(raw_scss, config)
fileChangeHandler.on_any_event = on_change
path = config['scss_dir']
observer = Observer()
observer.schedule(
fileChangeHandler,
path,
recursive=True
)
observer.start()
try:
print(f"\nWatching {config['scss_dir']}...")
print("Press Ctrl + C to stop.")
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def event_handler_factory(self,
*args,
patterns=["*"],
ignore_directories=True,
**kwargs):
event_handler = PatternMatchingEventHandler(
*args,
patterns=patterns,
ignore_directories=ignore_directories,
**kwargs)
def on_any_event_callback(event):
"""
Callback to react on any watchdog filesystem event.
"""
containers = self.get_target_containers()
if containers:
logger.info(event)
logger.info(f"Scheduling reloading of containers")
self.scheduled_reload(containers)
event_handler.on_any_event = on_any_event_callback
return event_handler
def main():
"""CLI Command to execute the provided script with pymon"""
init()
# CLI Argument Parser
parser = argparse.ArgumentParser(
prog="pymon", description="Executes the provided script with pymon")
# Adding arguments to the command
parser.add_argument("filename",
type=str,
help="The file to execute with pymon",
metavar="filename")
parser.add_argument("--all",
action="store_true",
default=False,
help="Watch all python Files in directory",
dest="all_py")
parser.add_argument("--force-kill",
action="store_true",
default=False,
help="Force kills the file instead of terminating it",
dest="force_kill")
# Fetch arguments
arguments = parser.parse_args()
event_handler = PatternMatchingEventHandler(
patterns=['*.py' if arguments.all_py else arguments.filename])
observer = Observer()
observer.schedule(event_handler, getcwd(), recursive=True)
observer.start()
def _run_file():
global process
process = subprocess.Popen([executable, arguments.filename])
def handle_event(event):
file_change_type = event.event_type
print(Fore.GREEN +
"[pymon] restarting due to {}...".format(file_change_type) +
Style.RESET_ALL)
process.kill() if arguments.force_kill else process.terminate()
if file_change_type == 'deleted':
exit()
elif file_change_type == 'modified':
_run_file()
def _prompt_terminate():
confirm_terminate = input('Are you sure you want to Terminate?(Y|n) ')
if confirm_terminate.lower() == 'y':
observer.stop()
event_handler.on_any_event = handle_event
if arguments.all_py:
print(Fore.YELLOW + Style.BRIGHT + f"[pymon] watching Directory`" +
Style.RESET_ALL)
print(Fore.GREEN + f"[pymon] starting `python {arguments.filename}`" +
Style.RESET_ALL)
_run_file()
try:
while True:
pass
except KeyboardInterrupt:
_prompt_terminate()
observer.join()
src_dir = args.src
dest_dir = args.dest
if not is_dest_in_user_dir(dest_dir):
print('! Destination path not in user folder, exiting now !')
exit(1)
# Run once initially
replace_dest_with_src(src_dir, dest_dir)
convert_all_mcf_files(dest_dir)
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
pattern_event_handler = PatternMatchingEventHandler(
patterns, ignore_patterns, ignore_directories, case_sensitive)
pattern_event_handler.on_any_event = on_watchdog_event
observer = Observer()
observer.schedule(pattern_event_handler, src_dir, recursive=True)
observer.start()
try:
while True:
time.sleep(1)
while len(QUEUE) > 0:
handle_fs_change_event(QUEUE.pop())
except KeyboardInterrupt:
observer.stop()
observer.join()
def __init__(self, host, port, content_dir='.'):
self.host = host
self.port = port
self.content_dir = content_dir
self.status_codes = {
100: 'Continue',
101: 'Switching Protocols',
102: 'Processing',
103: 'Early Hints',
200: 'OK',
201: 'Created',
202: 'Accepted',
203: 'Non-Authoritative Information',
204: 'No Content',
205: 'Reset Content',
206: 'Partial Content',
207: 'Multi-Status',
208: 'Already Reported',
226: 'IM Used',
300: 'Multiple Choices',
301: 'Moved Permanently',
302: 'Found',
303: 'See Other',
304: 'Not Modified',
305: 'Use Proxy',
306: 'Switch Proxy',
307: 'Temporary Redirect',
308: 'Permanent Redirect',
400: 'Bad Request',
401: 'Unauthorized',
402: 'Payment Required',
403: 'Forbidded',
404: 'Not Found',
405: 'Method Not Allowed',
406: 'Not Acceptable',
407: 'Proxy Authentication Required',
408: 'Request Timeout',
409: 'Conflict',
410: 'Gone',
411: 'Length Required',
412: 'Precondition Failed',
413: 'Payload Too Large',
414: 'URI Too Long',
415: 'Unsupported Media Type',
416: 'Range Not Satisfiable',
417: 'Expectation Failed',
418: "I'm a cup of coffee :3",
421: 'Misdirected Request',
422: 'Unprocessable Entity',
423: 'Locked',
424: 'Failed Dependency',
425: 'Too Early',
426: 'Upgrade Required',
428: 'Precondition Required',
429: 'Too Many Requests',
431: 'Request Header Fields Too Large',
451: 'Unavailable For Legal Reasons',
500: 'Internal Server Error',
501: 'Not Implemented',
502: 'Bad Gateway',
503: 'Service Unavailable',
504: 'Gateway Timeout',
505: 'HTTP Version Not Supported',
506: 'Variant Also Negotiates',
507: 'Insufficient Storage',
508: 'Loop Detected',
510: 'Not Extended',
511: 'Network Authentication Required'
}
self.headers = {
'Server': 'SAI',
'Content-Type': 'text/html',
'Connection': 'keep-alive'
}
self.driver = webdriver.Chrome(
os.path.join(os.path.abspath(os.getcwd()), 'src',
'chromedriver.exe'))
event_handler = PatternMatchingEventHandler(patterns="*",
ignore_patterns="",
ignore_directories=False,
case_sensitive=True)
event_handler.on_any_event = self.on_file_event
self.observer = Observer()
self.observer.schedule(event_handler=event_handler,
path=self.content_dir,
recursive=True)
def run(application_path: 'the path to the application to run',
reloader: 'reload the application on changes' = False,
workers: 'the number of asynchronous tasks to run' = 1,
debug: 'enable debug mode' = False,
**kwargs):
"""Import and run an application."""
if kwargs['quiet']:
# If quiet mode has been enabled, set the number of verbose
# flags to -1 so that the level above warning will be used.
verbosity = -1
else:
# argparse gives None not 0.
verbosity = kwargs['verbose'] or 0
# Set the log level based on the number of verbose flags. Do this
# before the app is imported so any log calls made will respect the
# specified level.
log_level = logging.WARNING - (verbosity * 10)
logging.basicConfig(level=log_level)
import_path, app = _import_application(application_path)
# Now that we have an application, set it's log level, too.
app.logger.setLevel(log_level)
if reloader or debug:
# If the reloader is requested (or debug is enabled), create
# threads for running the application and watching the file
# system for changes.
app.logger.info('Running {!r} with reloader...'.format(app))
# Find the root of the application and watch for changes
watchdir = os.path.abspath(import_module(import_path).__file__)
for _ in import_path.split('.'):
watchdir = os.path.dirname(watchdir)
# Create observer and runner threads
observer = Observer()
loop = _new_event_loop()
runner = Thread(
target=app.run_forever,
kwargs={'num_workers': workers, 'loop': loop, 'debug': debug},
)
# This function is called by watchdog event handler when changes
# are detected by the observers
def restart_process(event):
"""Restart the process in-place."""
os.execv(sys.executable, [sys.executable] + sys.argv[:])
# Create the handler and watch the files
handler = PatternMatchingEventHandler(
patterns=['*.py', '*.ini'],
ignore_directories=True,
)
handler.on_any_event = restart_process
observer.schedule(handler, watchdir, recursive=True)
# Start running everything
runner.start()
observer.start()
else:
# If the reloader is not needed, avoid the overhead
app.logger.info('Running {!r} forever...'.format(app))
app.run_forever(num_workers=workers, debug=debug)
generator.generate_all()
def event_proc(event):
generator.generate_all()
patterns = ['*']
ignore_patterns = [
os.path.join('.', conf.OUTPUT_DIR) + '*',
os.path.join('.', DB_FILE)
]
ignore_dirs = False
case_sensitive = True
event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_dirs, case_sensitive)
event_handler.on_any_event = event_proc
observer = Observer()
observer.schedule(event_handler, '.', True)
observer.start()
try:
serve_path = os.path.join(CWD, conf.OUTPUT_DIR)
Handler = functools.partial(http.server.SimpleHTTPRequestHandler,
directory=serve_path)
with socketserver.TCPServer(("", HTTP_PORT), Handler) as httpd:
print("serving at port", HTTP_PORT)
httpd.serve_forever()
except KeyboardInterrupt:
observer.stop()
observer.join()
def run(application_path: 'the path to the application to run',
reloader: 'reload the application on changes' = False,
workers: 'the number of asynchronous tasks to run' = 1,
debug: 'enable debug mode' = False,
**kwargs):
"""Import and run an application."""
if kwargs['quiet']:
# If quiet mode has been enabled, set the number of verbose
# flags to -1 so that the level above warning will be used.
verbosity = -1
else:
# argparse gives None not 0.
verbosity = kwargs['verbose'] or 0
# Set the log level based on the number of verbose flags. Do this
# before the app is imported so any log calls made will respect the
# specified level.
log_level = logging.WARNING - (verbosity * 10)
logging.basicConfig(level=log_level)
import_path, app = _import_application(application_path)
# Now that we have an application, set it's log level, too.
app.logger.setLevel(log_level)
if reloader or debug:
# If the reloader is requested (or debug is enabled), create
# threads for running the application and watching the file
# system for changes.
app.logger.info('Running {!r} with reloader...'.format(app))
# Find the root of the application and watch for changes
watchdir = os.path.abspath(import_module(import_path).__file__)
for _ in import_path.split('.'):
watchdir = os.path.dirname(watchdir)
# Create observer and runner threads
observer = Observer()
loop = _new_event_loop()
runner = Thread(
target=app.run_forever,
kwargs={
'num_workers': workers,
'loop': loop,
'debug': debug
},
)
# This function is called by watchdog event handler when changes
# are detected by the observers
def restart_process(event):
"""Restart the process in-place."""
os.execv(sys.executable, [sys.executable] + sys.argv[:])
# Create the handler and watch the files
handler = PatternMatchingEventHandler(
patterns=['*.py', '*.ini'],
ignore_directories=True,
)
handler.on_any_event = restart_process
observer.schedule(handler, watchdir, recursive=True)
# Start running everything
runner.start()
observer.start()
else:
# If the reloader is not needed, avoid the overhead
app.logger.info('Running {!r} forever...'.format(app))
app.run_forever(num_workers=workers, debug=debug)
available_dir.sort()
if len(available_dir) == 0: available_dir.insert(0, '')
if len(available_dir) >= 2: set_activedir(1)
else: set_activedir(0)
print('File list updated')
def file_change(event):
global refreshTimer
if not refreshTimer:
refreshTimer = Timer(3.0, refresh_filelist)
refreshTimer.start()
my_event_handler = PatternMatchingEventHandler("*", "", False, True)
my_event_handler.on_any_event = file_change
my_observer = Observer()
my_observer.schedule(my_event_handler, base_path, recursive=True)
my_observer.start()
player.setBasePath(base_path)
def play_activedir(index):
broadcast('/playlist', current_dir(), index)
broadcast('/scene', available_dir[active_dir])
def play_lastdir(index):
sel_lastdir()
play_activedir(index)
