def test___init__(self):
handler1 = RegexMatchingEventHandler(g_allowed_regexes, g_ignore_regexes, True)
handler2 = RegexMatchingEventHandler(g_allowed_regexes, g_ignore_regexes, False)
self.assertEqual([r.pattern for r in handler1.regexes], g_allowed_regexes)
self.assertEqual([r.pattern for r in handler1.ignore_regexes], g_ignore_regexes)
self.assertTrue(handler1.ignore_directories)
self.assertFalse(handler2.ignore_directories)
def test_ignore_directories():
handler1 = RegexMatchingEventHandler(g_allowed_regexes,
g_ignore_regexes, True)
handler2 = RegexMatchingEventHandler(g_allowed_regexes,
g_ignore_regexes, False)
assert handler1.ignore_directories
assert not handler2.ignore_directories
def test_ignore_directories(self):
handler1 = RegexMatchingEventHandler(g_allowed_regexes,
g_ignore_regexes, True)
handler2 = RegexMatchingEventHandler(g_allowed_regexes,
g_ignore_regexes, False)
self.assertTrue(handler1.ignore_directories)
self.assertFalse(handler2.ignore_directories)
def test_handler():
handler1 = RegexMatchingEventHandler(g_allowed_regexes,
g_ignore_regexes, True)
handler2 = RegexMatchingEventHandler(g_allowed_regexes,
g_ignore_regexes, False)
assert [r.pattern for r in handler1.regexes] == g_allowed_regexes
assert [r.pattern for r in handler1.ignore_regexes] == g_ignore_regexes
assert handler1.ignore_directories
assert not handler2.ignore_directories
def reload(file, logger):
path = os.path.dirname(os.path.abspath(file))
handler = RegexMatchingEventHandler([r".*"], [], False, True)
handler.on_modified = on_modified(logger)
my_observer = Observer()
my_observer.schedule(handler, path, recursive=True)
my_observer.start()
def _watch_reducers(self):
event_handler = RegexMatchingEventHandler(['.*'])
event_handler.on_modified = self._on_reducer_modifed
observer = Observer()
observer.schedule(event_handler,
os.path.join(ROOT_DIR, 'reducers'),
recursive=False)
observer.start()
def main():
# load config and values
loadConfig()
# clean up any unix accoutn that was not removed
cleanupZombieUsers()
# Start the file watch service
fileEventHandler = RegexMatchingEventHandler(regexMatch, ignore_patterns,
ignoreDirectories,
caseSensitive)
fileEventHandler.on_modified = watchFile.on_modified
my_observer = Observer()
my_observer.schedule(fileEventHandler, path, recursive=goRecursively)
my_observer.start()
"""Start the bot."""
# Create the Updater and pass it your bot's token.
# Make sure to set use_context=True to use the new context based callbacks
# Post version 12 this will no longer be necessary
updater = Updater(TOKEN, use_context=True)
# Get the dispatcher to register handlers
dispatcher = updater.dispatcher
# on different commands - answer in Telegram
dispatcher.add_handler(CommandHandler("start", start))
dispatcher.add_handler(CommandHandler("help", help_command))
dispatcher.add_handler(CommandHandler("restart", restart_command))
dispatcher.add_handler(CommandHandler("backup", backup_command))
dispatcher.add_handler(CommandHandler("perm", perm_command))
dispatcher.add_handler(CommandHandler("genssh", genSSH_command))
dispatcher.add_handler(CommandHandler("list", list_command))
dispatcher.add_handler(CommandHandler("clone", clone_command))
dispatcher.add_handler(CommandHandler("op", op_command))
dispatcher.add_handler(CommandHandler("deop", deop_command))
dispatcher.add_handler(CommandHandler("hwinfo", hwinfo_command))
dispatcher.add_handler(CommandHandler("broadcast", broadcast_command))
dispatcher.add_handler(CommandHandler("test", test_command))
dispatcher.add_handler(CommandHandler("players", players_command))
dispatcher.add_handler(CommandHandler("status", status_command))
dispatcher.add_handler(CommandHandler("propGet", propGet_command))
dispatcher.add_handler(CommandHandler("cmd", anyCommand_command))
dispatcher.add_handler(CommandHandler("mapreg", mapReg_command))
# dispatcher.add_handler(CommandHandler("kb", kb))
updater.dispatcher.add_handler(CallbackQueryHandler(button))
# on noncommand i.e message - echo the message on Telegram
dispatcher.add_handler(
MessageHandler(Filters.text & ~Filters.command, badCMD))
# Start the Bot
updater.start_polling()
# Run the bot until you press Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT. This should be used most of the time, since
# start_polling() is non-blocking and will stop the bot gracefully.
updater.idle()
def get_event_handler(converter):
def on_created(event):
converter(event.src_path)
def on_modified(event):
print(f'[MODIFIED] {event.__dict__}')
handler = RegexMatchingEventHandler(regexes=[r".*[.]djvu"])
handler.on_created = on_created
handler.on_modified = on_modified
return handler
def _watcher(self):
handler = RegexMatchingEventHandler(regexes=[self.regex],
ignore_directories=True)
handler.on_modified = lambda x: self.q.put(x.src_path)
observer = Observer()
observer.schedule(handler, self.path)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def __init__(self, warehouse, file_path, **kwargs):
super().__init__(**kwargs)
self.warehouse = warehouse
self.file_path = file_path
self.observer = None
patterns = str(self.file_path)
ignore_patterns = ""
ignore_directories = True
case_sensitive = True
self.my_event_handler = RegexMatchingEventHandler(
patterns, ignore_patterns, ignore_directories, case_sensitive)
self.my_event_handler.on_created = self.on_created
self.my_event_handler.on_modified = self.on_modified
setup_logging("debug", f"listener.log")
def start(self):
"""
Starts watchdog thread to monitor for incoming files. Calls the
child class's `read` method when a new file appears.
"""
print 'FileSource start method called...', self.directory
event_handler = RegexMatchingEventHandler(regexes=['.*'],
ignore_regexes=[],
ignore_directories=False,
case_sensitive=False)
event_handler.on_created = self.read # Call child's `read` method
event_handler.on_modified = self.read
watch_path = self.directory
observer = Observer()
observer.schedule(event_handler, watch_path, recursive=False)
observer.start()
print 'observer started.'
def __init__(self, path: str, watchdog_queue: Queue,
rabbitmq_queue: str) -> None:
self.rabbitmq_queue = rabbitmq_queue
self.path = path
self.event_handler = RegexMatchingEventHandler(
regexes=self.regexes,
ignore_directories=self.ignore_directories,
case_sensitive=self.case_sensitive,
)
self.event_handler.on_created = self.__on_created_event
self.watchdog_queue = watchdog_queue
for file in listdir(path):
fpath = join(path, file)
if isfile(fpath):
event = FileCreatedEvent(fpath)
self.watchdog_queue.put(item=event)
while not watchdog_queue.empty():
self.__on_created_event(watchdog_queue.get())
def main():
if len(sys.argv) < 2:
print(f"Error: At least one arg is required. Usage: miro_uploader <destination_path> [monitored_path]")
exit(1)
destination_path = sys.argv[1]
monitored_path = sys.argv[2] if len(sys.argv) > 2 else '.'
def on_created(event):
print(f"hey, {event.src_path} has been created!")
def on_modified(event):
try:
print(f"hey buddy, {event.src_path} has been modified")
return_path = copy2(event.src_path, destination_path)
print(f"hey, that a copy path {return_path}")
remove(event.src_path)
except Exception:
pass
event_handler = RegexMatchingEventHandler(regexes=[r"^[\x00-\x7F]*jpg$"],
ignore_directories=True, case_sensitive=False)
event_handler.on_created = on_created
event_handler.on_modified = on_modified
observer = Observer()
observer.schedule(event_handler, monitored_path, recursive=False)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
finally:
observer.stop()
observer.join()
def main(argv):
################################################### get options
global path
global my_observer
global stop
print(str(argv))
print(len(argv))
if len(argv) ==1:
print('add parameters: ')
params=input().split(' ')
else:
params=argv[1:]
try:
opts, args = getopt.getopt( params ,"hp:",["help","path="])
print('try ok')
except getopt.GetoptError:
print('file_sync_to_gdrive_windows -p "path/to/git/project')
sys.exit(2)
print('opts'+str(opts))
print('args'+str(args))
if len(opts) < len(args):
print('file_sync_to_gdrive_windows -p "path/to/git/project')
exit()
for opt, arg in opts:
if opt in ('-h','--help'):
print('file_sync_to_gdrive_windows -p "path/to/git/project')
sys.exit()
elif opt in ("-p", "--path"):
path = arg
print("incase of module log path:" + path + "\\auto_sync_console.log")
log('path:' + path)
else:
print('not recognize')
#patterns = ["*"]
#ignore_patterns = [".*git"]
ignore_directories = False
case_sensitive = True
#my_event_handler = PatternMatchingEventHandler(patterns, ignore_patterns, ignore_directories, case_sensitive)
regexes = [".+"]
#ignore = ".*c:/Users/eharvin/OneDrive - Ericsson AB/000Vince/programming/git/scripts\\\\.git.*"
#c:/Users/eharvin/OneDrive - Ericsson AB/000Vince/programming/git/scripts
#ignore_windows = "^" + path + "\\\\.git.*"
#ignore_regexes = [".*\\\\.git$"]
#ignore_regexes = ["git"]
#ignore_linux = "^" + path + "/\\.git.*"
#ignore_regexes = [ignore_windows, ignore_linux]
#log("ignore: " + ignore_linux)
if os.name == 'nt':
ignore = "^" + re.escape(path) + "\\\\\\.git.*"
else:
ignore = "^" + path + "/\\.git.*"
log("ignore: " + ignore)
ignore_regexes = [ignore]
my_event_handler = RegexMatchingEventHandler (regexes=regexes,ignore_regexes=ignore_regexes, ignore_directories=ignore_directories, case_sensitive=case_sensitive)
my_event_handler.on_created = on_created
my_event_handler.on_deleted = on_deleted
my_event_handler.on_modified = on_modified
my_event_handler.on_moved = on_moved
go_recursively = True
my_observer = Observer()
my_observer.schedule(my_event_handler, path, recursive=go_recursively)
my_observer.start()
try:
while True:
time.sleep(1)
if stop:
break
except KeyboardInterrupt:
my_observer.stop()
my_observer.join()
def test_regexes(self):
handler1 = RegexMatchingEventHandler(g_allowed_regexes, g_ignore_regexes, True)
self.assertEqual([r.pattern for r in handler1.regexes], g_allowed_regexes)
def test_regexes():
handler1 = RegexMatchingEventHandler(g_allowed_regexes,
g_ignore_regexes, True)
assert [r.pattern for r in handler1.regexes] == g_allowed_regexes
def FileHandler():
handler = RegexMatchingEventHandler(regexes=[r".*[.](epub|pdf|mobi)"])
return handler
if __name__ == '__main__':
FORMAT = '%(asctime)-15s %(message)s'
logging.basicConfig(filename='/tmp/watchdog.log',
level=logging.INFO,
format=FORMAT)
logging.info('Started')
path = sys.argv[1] if len(sys.argv) > 1 else '/home/norbert/Desktop'
patterns = ['.+']
ignore_patterns = [f"^{path}\.+"]
ignore_dirs = False
case_sensitive = True
my_event_handler = RegexMatchingEventHandler(patterns, ignore_patterns,
ignore_dirs, case_sensitive)
my_event_handler.on_created = on_created
my_event_handler.on_deleted = on_delete
my_event_handler.on_moved = on_moved
my_event_handler.on_modified = on_modified
go_recursively = True
my_observer = Observer()
my_observer.schedule(my_event_handler, path, recursive=go_recursively)
my_observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
def on_modified(event):
print(f"{event.src_path} has been modified")
os.system(f"git add .")
os.system(f"git commit -m '{event.src_path} modified'")
os.system("git push origin master")
# create the event handler
if __name__ == "__main__":
# patterns = [".*"]
ignore_patterns = ["^./.git"]
ignore_directories = False
case_sensitive = True
# my_event_handler = RegexMatchingEventHandler(patterns, ignore_patterns, ignore_directories, case_sensitive)
my_event_handler = RegexMatchingEventHandler(
ignore_regexes=ignore_patterns)
my_event_handler.on_created = on_created
my_event_handler.on_deleted = on_deleted
my_event_handler.on_modified = on_modified
# create an observer
path = "."
go_recursively = True
my_observer = Observer()
my_observer.schedule(my_event_handler, path, recursive=go_recursively)
my_observer.start()
# try:
# while True:
# time.sleep(5)
def KindleConnectionHandler():
handler = RegexMatchingEventHandler(regexes=[r".*/Kindle"])
return handler
device = user.getDevice(2314)
print(f'Connected to {device.name}')
# Define what to do when data is detected
def onDataDetected(event):
device.addData(fieldName='Raw Data File',
fieldType='file',
filepath=event.src_path)
# Use watchdog built in regex event handler
# This will detect files that end in .csv
my_event_handler = RegexMatchingEventHandler([r".*\.csv$"])
# Set the handler for when files are created
my_event_handler.on_created(onDataDetected)
# Set up the watchdog observer to watch a specific folder
my_observer = Observer()
path = '/path/to/device/output/folder'
my_observer.schedule(my_event_handler, path)
# Start the observer
my_observer.start()
# Set up loop to stop the script terminating unless interupted
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
my_observer.stop()