from glob import glob
import hashlib
import json
import os
import sys
from time import sleep, time
from watchdog.observers import Observer
from watchdog.observers.api import EventQueue
from import PatternMatchingEventHandler
# ---------------- Configuration ---------------------------------------------
# Replace the RSYNC_TO string appropriately (and set up public key
# authentication for ssh), or set RSYNC_TO to None if you want to use scp
# instead.
# If you want to use scp to upload files, install the paramiko and scp packages
# and set the server address and directory on the server here. (You must create
# the directory on the server beforehand.)
SERVER = None # ''
UPLOAD_DIRECTORY = None # '/homes/hx0050/public_html/live'
SSH_USERNAME = None # 'hx0050'
# If you want to use scp to upload files, set up public key authentication for
# ssh (preferably - if an SSH agent is running, this should be used
# automatically by paramiko; if your private key is password protected and no
# SSH agent is running, you need to provide the password for the key here), or
# replace None in the next line by your password.
# -----------------------------------------------------------------------------
if not RSYNC_TO:
    # open ssh connection
    from paramiko import SSHClient
    from scp import SCPClient
    ssh = SSHClient()
    ssh.connect(SERVER, username=SSH_USERNAME, password=SSH_PASSWORD)
    # SCPCLient takes a paramiko transport as an argument
    scp = SCPClient(ssh.get_transport())
# SOURCE_DIR will be watched for changes to *.xopp files.
SOURCE_DIR = sys.argv[1]
# In OUTPUT_DIR, a directory "png-source" will be created which will hold
# the png files exported by xournal++, and a directory "png-upload" will be
# created which holds the files that should be uploaded to the web server.
OUTPUT_DIR = sys.argv[2]
# The title to be displayed on the web page.
TITLE = sys.argv[3]
# List of files we uploaded already
uploaded_files = []
def md5sum_file(filename, blocksize=65536):
    '''Computes the md5 hash of the given file and returns the first ten digits
    of its hexadecimal presentation.'''
    hash = hashlib.md5()
    with open(filename, "rb") as f:
        for block in iter(lambda:, b""):
    return hash.hexdigest()[:10]
def upload_files():
    slides = []
    # Go through the new slides and add hash codes. This ensures that a slide
    # gets a new name when changed. This ensures that only changed/new slides
    # are uploaded to the web server and also avoids that the web page is not
    # updated as it should because of caching.
    for path in sorted(glob(os.path.join(OUTPUT_DIR, 'png-source', '*.png'))):
        MD5SUM = md5sum_file(path)
        fn = os.path.basename(path)
            os.path.join(OUTPUT_DIR, 'png-upload', '%s-%s.png' % (fn, MD5SUM, )))
        slides.append((fn, MD5SUM, ))
    # Compute a timestamp and store it together with the current list of slides.
    # The javascript running on the web page can compare its own timestamp with
    # the one stored in the current version of the timestamp.kson file in order
    # to decide whether the slides need to be updated (which is the case when
    # those two timestamps differ).
    timestamp = hashlib.md5(
        ''.join(s[1] for s in slides).encode('utf-8')).hexdigest()
    result = [timestamp, TITLE, ] + ["%s-%s.png" % s for s in slides]
    with open(os.path.join(OUTPUT_DIR, 'png-upload', 'timestamp.json'), 'w') as f:
    # print(result)
    # Upload the timestamp.json file and the new slide files to the web server
    if RSYNC_TO:
            f'command rsync -cr -e ssh {OUTPUT_DIR}/png-upload/ {RSYNC_TO}')
            os.path.join(OUTPUT_DIR, 'png-upload', 'timestamp.json'),
        for s in result[2:]:
            if s in uploaded_files:
            # print('Uploading', s)
                os.path.join(OUTPUT_DIR, 'png-upload', s),
class MyEventHandler(PatternMatchingEventHandler):
    # (On my system at least, ) when a xournal file is "Saved as" (i.e., an
    # on_created event happens), actually saving that file happens in several
    # steps, so it also triggers an on_modified event shortly thereafter. It is
    # therefore sufficient to listen to on_modified events only.
    # def on_created(self, event):
    #     queue.put(event)
    def on_modified(self, event):
if __name__ == '__main__':
    # Create directories if necessary
    for d in ['png-source', 'png-upload', ]:
        if not os.path.exists(os.path.join(OUTPUT_DIR, d)):
                os.mkdir(os.path.join(OUTPUT_DIR, d))
                print('Failed to create directory', os.path.join(OUTPUT_DIR, d))
    event_handler = MyEventHandler(patterns=['*.xopp', '.*.xopp', ])
    queue = EventQueue()
    observer = Observer()
    observer.schedule(event_handler, SOURCE_DIR, recursive=True)
    print("Watching for changes ...")
        while True:
            # wait for 3 seconds between checking for file modification events
            if not queue.empty():
                # (Auto-)saving a file triggers several file modification events
                # within 50 milliseconds or so. Therefore we wait here for
                # another second to ensure that we do not use a version of the
                # file that does not have all changes that were to be saved.
                event = queue.get()
                print('File modification', time(), event)
                if event.is_directory:
                result = os.system('xournalpp --create-img=%s %s'
                                   % (os.path.join(
                                      event.src_path, ))
                if result == 0:
                    print("Conversion failed.")
        if not RSYNC_TO: