def run(self):
"""
Runs a continuous while loop to maintain the running state of the program
"""
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
event_handler = PatternMatchingEventHandler(self.patterns,
self.ignore_patterns,
self.ignore_directories,
self.case_sensitive)
# event_handler.on_deleted = self.on_deleted
# event_handler.on_modified = self.on_modified
event_handler.on_moved = self.on_moved
event_handler.on_created = self.on_created
go_recursively = True
observer = Observer()
observer.schedule(event_handler, self.path, recursive=go_recursively)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def start(self, root):
self.root = root
patterns = ["*.edd"]
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
my_event_handler = PatternMatchingEventHandler(patterns,
ignore_patterns,
ignore_directories,
case_sensitive)
my_event_handler.on_created = self.on_created
my_event_handler.on_modified = self.on_modified
go_recursively = False
path = config.app_dir
# edmc may be slow starting, stored/current may already be there, process
stored = join(path, "stored.edd")
if os.path.exists(stored):
print("Stored exists, processing")
self.readfile(stored)
current = join(path, "current.edd")
if os.path.exists(current):
print("Current exists, processing")
self.readfile(current)
my_observer = Observer()
my_observer.schedule(my_event_handler, path, recursive=go_recursively)
my_observer.start()
def notify():
#------------------------
# Setup watchdog patterns
#------------------------
#patterns = "*"
patterns = ["*full.jpg"]
ignore_patterns = ""
ignore_directories = False
case_sensitive = False
#path = "c://self//UniWatch2//static//images"
path = watchConfig.config['fileWatch']['pathToImagesUnifi']
go_recursively = True
#------------------------
# Setup watchdog handlers
#------------------------
event_handler = PatternMatchingEventHandler(patterns, ignore_patterns, ignore_directories, case_sensitive)
event_handler.on_created = on_file_created
#event_handler.on_modified = on_file_created
#observer = Observer()
observer = PollingObserver()
observer.schedule(event_handler, path, recursive=go_recursively)
#observer.schedule(event_handler, path, recursive=False)
observer.start()
def stream(graph, tags, communities, args):
# Code credit: http://thepythoncorner.com/dev/how-to-create-a-watchdog-in-python-to-look-for-filesystem-changes/
event_handler = PatternMatchingEventHandler(patterns=["*.md"],
case_sensitive=True)
smds_event_handler = SMDSEventHandler(graph, tags, communities, args)
event_handler.on_created = smds_event_handler.on_created()
event_handler.on_deleted = smds_event_handler.on_deleted()
event_handler.on_modified = smds_event_handler.on_modified()
event_handler.on_moved = smds_event_handler.on_moved()
observer = Observer()
path = Path(args.input)
if smdc.DEBUG:
print(path.absolute(), flush=True)
observer.schedule(event_handler, path=Path(args.input), recursive=args.r)
observer.start()
try:
print("Stream is active!", flush=True)
import sys
sys.stdout.flush()
while True:
# TODO: Catch when connection to neo4j server is down.
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def run(self):
self.curr_time = self.get_time()
patterns = "*"
ignore_patterns = "*\logs.txt", "*\logs.csv", "*\logs", "*.py"
ignore_directories = False
case_sensitive = True
my_event_handler = PatternMatchingEventHandler(patterns,
ignore_patterns,
ignore_directories,
case_sensitive)
my_event_handler.on_created = self.on_created
my_event_handler.on_deleted = self.on_deleted
my_event_handler.on_modified = self.on_modified
my_event_handler.on_moved = self.on_moved
path = ".\\" + self.path_to_watch
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:
my_observer.stop()
my_observer.join()
def main(verbose, observer, directory):
"""
Run main application with can interface
"""
# Verbose output
if verbose is True:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
# watchdog
if observer is True:
patterns = ["*"]
ignore_patterns = None
ignore_directories = False
case_sensitive = True
event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
event_handler.on_created = start_import(directory)
event_handler.on_modified = start_import(directory)
observer = Observer()
observer.schedule(event_handler, directory, recursive=True)
observer.start()
try:
while True:
time.sleep(1)
finally:
observer.stop()
observer.join()
else:
start_import(directory)
def start_watch(input_dir, output_dir, pretty=False):
logging.basicConfig(format="%(asctime)s - %(message)s", level=logging.INFO)
logging.info(f"Beginning watch in {input_dir}")
logging.info(f"Writing files to: {output_dir}")
def handle_compile_event(event):
logging.info(f"Building file: {event.src_path}")
compile_file(input_dir, output_dir, Path(event.src_path), pretty=pretty)
patterns = ["*.sqp"]
IGNORE_PATTERNS = [".#*"]
sqp_event_handler = PatternMatchingEventHandler(
patterns, IGNORE_PATTERNS, ignore_directories=True
)
sqp_event_handler.on_modified = handle_compile_event
sqp_event_handler.on_created = handle_compile_event
observer = Observer()
observer.schedule(sqp_event_handler, str(input_dir), recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def watch_dir(path):
def on_file_created(event):
try:
run_dir = Dir(event.src_path)
except ValueError:
return None
if os.path.isdir(event.src_path):
# TODO: ensure this is the top level dir?
if run_dir.run_id and not find_run(run_dir.run_id):
print("New run started at %s" % run_dir.path)
data["Runs"].insert(0, run_dir.load())
run = find_run(run_dir.run_id)
run_dir.load(run)
def on_file_modified(event):
try:
run_dir = Dir(event.src_path)
except ValueError:
return None
run = find_run(run_dir.run_id)
run_dir.load(run)
handler = PatternMatchingEventHandler(
patterns=[os.path.join(path, "*")], ignore_patterns=['*/.*', '*.tmp'])
handler.on_created = on_file_created
handler.on_modified = on_file_modified
observer = Observer()
observer.schedule(handler, path, recursive=True)
observer.start()
def watch():
'''
This watches the folder for any changes. In this case, it watches for any creation of .txt files.
Once a file is created, it will go through and add the new tweets into the database.
The Tweet model catches any identical Tweet using the Tweet ID.
'''
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
my_event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
my_event_handler.on_created = on_created
path = "../example_data"
go_recursively = True
my_observer = Observer()
my_observer.schedule(my_event_handler, path, recursive=go_recursively)
my_observer.start()
try:
print("Starting program watching dir.")
while True:
time.sleep(1)
except KeyboardInterrupt:
print("Stopping program...")
my_observer.stop()
my_observer.join()
def listen():
print(colored.yellow("Getting files in directory"))
path = os.getcwd()
dircontents = os.listdir(path)
if len(dircontents) != 0:
print(colored.magenta("Currently listening for file changes"))
patterns = ['*.cpp', '*.py']
ignore_patterns = ['prog', '*.exe', '*.swp']
ignore_directories = True
case_sensitive = True
event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
event_handler.on_created = isModified
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
else:
print(colored.red("No files exist, check filename/path."))
async def observe(self):
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
my_event_handler = PatternMatchingEventHandler(patterns,
ignore_patterns,
ignore_directories,
case_sensitive)
my_event_handler.on_created = self.on_created
my_event_handler.on_modified = self.on_modified
path = self.__args.source
logger.info(f"Watching: {path}")
go_recursively = True
my_observer = Observer()
my_observer.schedule(my_event_handler, path, recursive=go_recursively)
my_observer.start()
try:
while not self.should_quit():
self.move_created_files()
await asyncio.sleep(self.SLEEP_SECONDS)
finally:
my_observer.stop()
my_observer.join()
def __init__(self, container, host_dir, container_dir, options=None):
"""
Initialize a new instance of ContainerNotifier
Args:
container: Container
host_dir (str): Host directory
container_dir (str): Container directory
"""
self.container = container
self.host_dir = host_dir
self.container_dir = container_dir
options = NotifierOptions() if options is None else options
event_handler = PatternMatchingEventHandler(
ignore_patterns=options.exclude_patterns, ignore_directories=False)
handler = self.__change_handler
event_handler.on_created = handler
event_handler.on_moved = handler
event_handler.on_modified = handler
if options.notify_debounce:
logging.info('File change events debouncing with %fs delay.',
options.notify_debounce)
self.notify_debounced = CallDebouncer(self.notify,
options.notify_debounce)
else:
self.notify_debounced = self.notify
self.observer = Observer()
self.observer.schedule(event_handler, host_dir, recursive=True)
self.observer.start()
def __init__(self):
# set up the values for the handler
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
# configure the handler
my_event_handler = PatternMatchingEventHandler(patterns,
ignore_patterns,
ignore_directories,
case_sensitive)
my_event_handler.on_created = self.on_created
my_event_handler.on_deleted = self.on_deleted
my_event_handler.on_modified = self.on_modified
my_event_handler.on_moved = self.on_moved
# set the path for the directory that should be watched
path = "../Reports"
go_recursively = True
# set up the observer to watch the directory
my_observer = Observer()
my_observer.schedule(my_event_handler, path, recursive=go_recursively)
my_observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
my_observer.stop()
my_observer.join()
def start(self):
"""Runs the watchdog service on the given path. Handles
various events to different functions as per the
requirement
"""
event_handler = PatternMatchingEventHandler(self.patterns,
self.ignore_patterns,
self.ignore_directories,
self.case_sensitive)
event_handler.on_created = self.__on_created
event_handler.on_deleted = self.__on_deleted
event_handler.on_modified = self.__on_modified
event_handler.on_moved = self.__on_moved
go_recursively = self.recursive
observer = Observer()
observer.schedule(
event_handler,
self.src_dir,
recursive=go_recursively
)
observer.start()
print(f'Started watching for changes on path {self.src_dir}')
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def watchFolder(conn):
# Keep watching the folder for any change
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
event_handler = PatternMatchingEventHandler(patterns, ignore_patterns, ignore_directories, case_sensitive)
def on_change(event):
# Update the file list with the indexing server
files = os.listdir("./")
register_data = {
"action": "UPDATE",
"filelist": files
}
register_json = json.dumps(register_data)
conn.send(register_json.encode(FORMAT))
event_handler.on_created = on_change
event_handler.on_deleted = on_change
path = "."
go_recursively = True
folder_observer = Observer()
folder_observer.schedule(event_handler, path, recursive=go_recursively)
folder_observer.start()
def __init__(self,
container,
host_dir,
container_dir,
exclude_patterns=None):
"""
Initialize a new instance of ContainerNotifier
Args:
container: Container
host_dir (str): Host directory
container_dir (str): Container directory
exclude_patterns (list): List of file name patterns for which changes should be ignored
"""
self.container = container
self.host_dir = host_dir
self.container_dir = container_dir
exclude_patterns = exclude_patterns if exclude_patterns else []
event_handler = PatternMatchingEventHandler(
ignore_patterns=exclude_patterns, ignore_directories=False)
handler = self.__change_handler
event_handler.on_created = handler
event_handler.on_moved = handler
event_handler.on_modified = handler
self.observer = Observer()
self.observer.schedule(event_handler, host_dir, recursive=True)
self.observer.start()
def update_progress(intervals, n, pathname):
if n == 0:
return 0, f'{0}%'
else:
for file in os.listdir('static/'):
os.remove('static/' + file)
patterns = '*.csv'
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
event_handler.on_created = on_created
path = 'static/'
go_recursively = True
observer = Observer()
observer.schedule(event_handler, path, recursive=go_recursively)
observer.start()
try:
while True:
time.sleep(1)
except pathname != '/':
observer.stop()
observer.join()
def main():
pipe_path = input_filter.pipe_path
if os.path.exists(pipe_path):
os.remove(pipe_path)
os.mkfifo(pipe_path)
config_path = os.path.abspath("config.yaml")
config = prepare_config(config_path)
handle_config_change = lambda *_: [
config.clear(),
config.update(prepare_config(config_path))
]
config_change_handler = PatternMatchingEventHandler([config_path])
config_change_handler.on_modified = handle_config_change
config_change_handler.on_created = handle_config_change
observer = Observer()
observer.schedule(config_change_handler, os.path.dirname(config_path))
observer.start()
while True:
pipe = os.open(pipe_path, os.O_RDONLY)
keyword = os.read(pipe, 1000).decode('utf-8')
os.close(pipe)
xmlitem = config.get(keyword, "")
repsonse = '<?xml version="1.0"?><items>{}</items>'.format(xmlitem)
pipe = os.open(pipe_path, os.O_WRONLY)
os.write(pipe, repsonse.encode('utf-8'))
os.close(pipe)
def setup_filesystem_watchdog(self):
"""
Initializes a filesystem watchdog (sets up file system event handler) and returns an observer object
"""
logging.debug("Initializing fs watchdog...")
# Unfortunately you can't ignore sub dirs with watchdog
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
fs_event_handler = PatternMatchingEventHandler(patterns,
ignore_patterns,
ignore_directories,
case_sensitive)
fs_event_handler.on_created = self.file_on_created
fs_event_handler.on_deleted = self.file_on_deleted
fs_event_handler.on_modified = self.file_on_modified
fs_event_handler.on_moved = self.file_on_moved
self.fs_observer = Observer()
self.fs_observer.schedule(fs_event_handler,
self.backup_src_path,
recursive=True)
logging.debug("fs watchdog created.")
def main():
"""
the watchdog checks source folder for created file.
when created, runs on_created function above
"""
patterns = "*" # patterns is what files to handle.
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
# event handler handles events that was observed via observer
my_event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
# initialize all events according to functions we made:
my_event_handler.on_created = on_created
my_event_handler.on_moved = on_moved # commented when on Yedidya's computer because it's unnecessary.
# create an observer:
src = source_folder
go_recursively = False # don't monitor also sub-directories, it causes issues..
my_observer = Observer()
my_observer.schedule(my_event_handler, src, recursive=go_recursively)
my_observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
my_observer.stop()
my_observer.join()
def _per_file_event_handler(self):
"""Create a Watchdog file event handler that does different things for every file
"""
file_event_handler = PatternMatchingEventHandler()
file_event_handler.on_created = self._on_file_created
file_event_handler.on_modified = self._on_file_modified
file_event_handler.on_moved = self._on_file_moved
file_event_handler._patterns = [
os.path.join(self._dir, os.path.normpath("*"))
]
# Ignore hidden files/folders
# TODO: what other files should we skip?
file_event_handler._ignore_patterns = [
"*.tmp",
"*.wandb",
"wandb-summary.json",
os.path.join(self._dir, ".*"),
os.path.join(self._dir, "*/.*"),
]
# TODO: pipe in actual settings
for glb in self._settings.ignore_globs:
file_event_handler._ignore_patterns.append(
os.path.join(self._dir, glb))
return file_event_handler
def watchdog(ctx, jobs="auto", sleep_time = 5):
"""
Start watchdog service to watch F90 files and execute `make` when changes are detected.
"""
from monty.termcolor import cprint
cprint("Starting watchdog service to watch F90 files and execute `make` when changes are detected", "green")
cprint("Enter <CTRL + C> in the terminal to kill the service.", "green")
cprint(f"Start watching py files with sleep_time {sleep_time} s ....", "green")
top = find_top_build_tree(".", with_abinit=True)
jobs = max(1, number_of_cpus() // 2) if jobs == "auto" else int(jobs)
# http://thepythoncorner.com/dev/how-to-create-a-watchdog-in-python-to-look-for-filesystem-changes/
# https://stackoverflow.com/questions/19991033/generating-multiple-observers-with-python-watchdog
import time
from watchdog.observers import Observer
from watchdog.events import PatternMatchingEventHandler
event_handler = PatternMatchingEventHandler(patterns="*.py", ignore_patterns="",
ignore_directories=False, case_sensitive=True)
def on_created(event):
print(f"hey, {event.src_path} has been created!")
def on_deleted(event):
print(f"what the f**k! Someone deleted {event.src_path}!")
def on_modified(event):
print(f"hey buddy, {event.src_path} has been modified")
cmd = "abicheck.py"
cprint("Executing: %s" % cmd, "yellow")
with cd(top):
try:
result = ctx.run(cmd, pty=True)
if result.ok:
cprint("Command completed successfully", "green")
cprint("Watching for changes ...", "green")
except Exception:
cprint(f"Command returned non-zero exit status", "red")
cprint(f"Keep on watching for changes hoping you get it right ...", "red")
def on_moved(event):
print(f"ok ok ok, someone moved {event.src_path} to {event.dest_path}")
event_handler.on_created = on_created
event_handler.on_deleted = on_deleted
event_handler.on_modified = on_modified
event_handler.on_moved = on_moved
path = ABIPY_ROOTDIR
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
try:
while True:
time.sleep(sleep_time)
except KeyboardInterrupt:
observer.stop()
observer.join()
def start(self):
path = self.config.get('watchdog', 'path')
patterns = self.config.get('watchdog', 'patterns').split(';')
ignore_directories = self.config.getboolean('watchdog',
'ignore_directories')
ignore_patterns = self.config.get('watchdog',
'ignore_patterns').split(';')
case_sensitive = self.config.getboolean('watchdog', 'case_sensitive')
recursive = self.config.getboolean('watchdog', 'recursive')
event_handler = PatternMatchingEventHandler(
patterns=patterns,
ignore_patterns=ignore_patterns,
ignore_directories=ignore_directories,
case_sensitive=case_sensitive)
event_handler.on_created = self.on_created
# event_handler.on_modified = self.on_modified
observer = Observer()
observer.schedule(path=path,
event_handler=event_handler,
recursive=recursive)
observer.start()
self.logger.info('WatchDog Observer for HCS/AFS/AAS is startting.....')
self.logger.info('patterns=%s' % patterns)
self.logger.info('path=%s' % path)
try:
while observer.is_alive():
time.sleep(1)
except (KeyboardInterrupt):
observer.stop()
self.logger.debug('WatchDog Observer is stoped.')
observer.join()
def startWatchdog():
if not Config.isSetted():
raise RuntimeError("Server not configured")
config = Config.config("library-watchdog")
print("Starting watchdog with config: " + str(config))
patterns = config["patterns"]
ignore_patterns = config["ignore-patterns"]
ignore_directories = config["ignore-directories"]
case_sensitive = config["case-sensitive"]
path = config["path"]
recursively = config["recursively"]
watchdog_events = PatternMatchingEventHandler(
patterns=patterns,
ignore_patterns=ignore_patterns,
ignore_directories=ignore_directories,
case_sensitive=case_sensitive)
watchdog_events.on_created = on_created
watchdog_events.on_deleted = on_deleted
watchdog_events.on_modified = on_modified
watchdog_events.on_moved = on_moved
observer = Observer()
observer.schedule(event_handler=watchdog_events,
recursive=recursively,
path=path)
observer.daemon = True
observer.start()
print("Watchdog started...")
return observer
def __init__(self, container, host_dir, container_dir):
"""
Initialize a new instance of ContainerNotifier
Args:
container: Container
host_dir (str): Host directory
container_dir (str): Container directory
"""
self.container = container
self.host_dir = host_dir
self.container_dir = container_dir
event_handler = PatternMatchingEventHandler(ignore_directories=True)
handler = self.__change_handler
event_handler.on_created = handler
event_handler.on_moved = handler
event_handler.on_modified = handler
self.ignore_file_pattern = '(\.idea|\.git|node_modules|___jb_old___|___jb_tmp___)'
if self.ignore_file_pattern:
self.ignore_file_pattern_compiled = re.compile(
self.ignore_file_pattern)
else:
self.ignore_file_pattern_compiled = None
self.observer = Observer()
self.observer.schedule(event_handler, host_dir, recursive=True)
self.observer.start()
def main():
print("Init Jinjaparser")
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
my_event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
my_event_handler.on_modified = build
my_event_handler.on_created = build
my_event_handler.on_modified = build
my_event_handler.on_moved = build
path = "./templates"
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:
my_observer.stop()
my_observer.join()
def popup_scan(self):
source_path = Path(__file__).resolve()
source_dir = str(source_path.parent) + "\\scans\\"
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
my_event_handler = PatternMatchingEventHandler(patterns,
ignore_patterns,
ignore_directories,
case_sensitive)
my_event_handler.on_created = self.on_created
my_event_handler.on_deleted = self.on_deleted
my_event_handler.on_modified = self.on_modified
my_event_handler.on_moved = self.on_moved
go_recursively = True
self.my_observer = Observer()
self.my_observer.schedule(my_event_handler,
source_dir,
recursive=go_recursively)
self.my_observer.start()
try:
self.open()
except KeyboardInterrupt:
self.my_observer.stop()
self.my_observer.join()
def main():
"""
Main function.
"""
logging.basicConfig(filename=CONFIG[SECTION]['log'],\
level=CONFIG[SECTION]['level'],\
format='%(asctime)s::%(name)s::%(funcName)s::%(levelname)s::%(message)s',\
datefmt="%Y-%m-%dT%H:%M:%S%z")
logger.info("############# Starting watcher ##############")
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
event_handler.on_created = on_created
#event_handler = LoggingEventHandler()
observer = Observer()
observer.schedule(event_handler, PATH)
observer.start()
try:
while True:
time.sleep(1)
finally:
observer.stop()
observer.join()
def start():
patterns = "*/auth.log"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
event_handler.on_created = on_created
event_handler.on_deleted = on_deleted
event_handler.on_modified = on_modified
event_handler.on_moved = on_moved
path = "/var/log/"
go_recursively = True
observer = Observer()
observer.schedule(event_handler, path, recursive=go_recursively)
observer.start()
try:
while True:
time.sleep(500)
except KeyboardInterrupt:
observer.stop()
observer.join()
def main(argv):
global my_observer
global stop
log("user:"******"*kisokos.txt"]
ignore_patterns = None
ignore_directories = False
case_sensitive = True
my_event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
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
path = "c:\\Users\\eharvin\\OneDrive - Ericsson AB\\00company"
go_recursively = False
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 on_created(self, event):
PatternMatchingEventHandler.on_created(self, event)
logging.info("Created file: %s", event.src_path)
make_py(event.src_path)
def main():
global signal_event
global ra_str
global dec_str
parser = argparse.ArgumentParser(description='Watches a folder for .jpg files and runs them through the astrometry.net solver.')
parser.add_argument('--watch-folder', required=True, help="folder to watch for new jpg files (will be created if it does not exist)")
parser.add_argument('--output-folder', required=True, help="folder to output solved information to (will be created if it does not exist)")
args = parser.parse_args()
watch_folder = args.watch_folder
output_folder = args.output_folder
mkdir_p(watch_folder)
mkdir_p(output_folder)
# AF_INET means IPv4.
# SOCK_STREAM means a TCP connection.
# SOCK_DGRAM would mean an UDP "connection".
listening_socket = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
listening_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# The parameter is (host, port).
# The host, when empty or when 0.0.0.0, means to accept connections for
# all IP addresses of current machine. Otherwise, the socket will bind
# itself only to one IP.
# The port must greater than 1023 if you plan running this script as a
# normal user. Ports below 1024 require root privileges.
listening_socket.bind( ("", 10001) )
# The parameter defines how many new connections can wait in queue.
# Note that this is NOT the number of open connections (which has no limit).
# Read listen(2) man page for more information.
listening_socket.listen(5)
listening_socket.setblocking(0)
listening_socket.settimeout(0.5)
def on_created(event):
global ra_str
global dec_str
logger.info('Found new file: {0}'.format(event.src_path))
# Sometimes we get the notification before the file is done being written. Wait half a second before processing.
e = Event()
e.wait(0.5)
e = None
result = solve(event.src_path, output_folder)
if result is not None:
ra_str = result[0]
dec_str = result[1]
event_handler = PatternMatchingEventHandler(patterns=["*.jpg"])
event_handler.on_created = on_created
observer = Observer()
observer.schedule(event_handler, watch_folder, recursive=True)
observer.start()
wait_time = 0.1
while not signal_event.wait(wait_time):
conn = None
try:
conn, addr = listening_socket.accept()
except socket.timeout as ex:
pass
except socket.error as ex:
if ex.errno == errno.EINTR:
# CTRL-C was pressed. Ignore the error.
pass
else:
logger.error(ex)
raise
if conn is not None:
conn.setblocking(0)
conn.settimeout(0.5)
logger.info('Connected...')
ra_str = None
dec_str = None
while not signal_event.wait(wait_time):
if ra_str is not None and dec_str is not None:
ra_str = ra_str[0:ra_str.rfind('.')]
dec_str = dec_str[0:dec_str.rfind('.')]
dec_str = dec_str.replace('+', '')
ra = functions.hourStr_2_rad(ra_str)
dec = functions.degStr_2_rad(dec_str)
result = functions.rad_2_stellarium_protocol(ra, dec)
t = time.time() * 1000000
# 2 bytes integer - Length of message (24)
# 2 bytes integer - 0
# 8 bytes integer - microseconds since epoch
# 4 bytes unsigned integer - RA
# 4 bytes signed integer - DEC
# 4 bytes status - 0 == OK
packet = (24, 0, t, result[0], result[1], 0)
reply = struct.pack('<hhqIii', 24, 0, t, result[0], result[1], 0)
#print reply
for i in range(10):
conn.send(reply)
ra_str = None
dec_str = None
data = None
try:
# recv can throw socket.timeout
data = conn.recv(20)
except socket.timeout as ex:
pass
except socket.error as ex:
if ex.errno == errno.EINTR:
# CTRL-C was pressed. Ignore the error.
pass
else:
logger.error(ex)
raise
if data is not None:
# 2 bytes integer - Length of message
# 2 bytes integer - 0
# 8 bytes integer - current time in microseconds since epoch
# 4 bytes unsigned integer - RA
# 4 bytes signed integer - DEC
data = struct.unpack("<hhqIi", data)
#print data
recieved_coords = functions.eCoords2str(data[3], data[4], data[2])
logger.info('Received slew command to (RA, DEC) = ({0}, {1})'.format(recieved_coords[0], recieved_coords[1]))
logger.warning('Disconnected...')
