primadiag-pybash/picowatch_d/picowatch.py

#!/usr/bin/env python

"""
pyboard interface

This module provides the Pyboard class, used to communicate with and
control the pyboard over a serial USB connection.

Example usage:

    import pyboard
    pyb = pyboard.Pyboard('/dev/ttyACM0')

Or:

    pyb = pyboard.Pyboard('192.168.1.1')

Then:

    pyb.enter_raw_repl()
    pyb.exec('pyb.LED(1).on()')
    pyb.exit_raw_repl()

Note: if using Python2 then pyb.exec must be written as pyb.exec_.
To run a script from the local machine on the board and print out the results:

    import pyboard
    pyboard.execfile('test.py', device='/dev/ttyACM0')

This script can also be run directly.  To execute a local script, use:

    ./pyboard.py test.py

Or:

    python pyboard.py test.py

"""

# Adafruit MicroPython Tool - File Operations
# Author: Tony DiCola
# Copyright (c) 2016 Adafruit Industries
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

import sys
import ast
import time
import textwrap
import binascii

import os
import signal

from watchdog.observers import Observer
from watchdog.events import PatternMatchingEventHandler


_rawdelay = None

try:
    stdout = sys.stdout.buffer
except AttributeError:
    # Python2 doesn't have buffer attr
    stdout = sys.stdout

def stdout_write_bytes(b):
    b = b.replace(b"\x04", b"")
    stdout.write(b)
    stdout.flush()

class PyboardError(Exception):
    pass

class TelnetToSerial:
    def __init__(self, ip, user, password, read_timeout=None):
        import telnetlib
        self.tn = telnetlib.Telnet(ip, timeout=15)
        self.read_timeout = read_timeout
        if b'Login as:' in self.tn.read_until(b'Login as:', timeout=read_timeout):
            self.tn.write(bytes(user, 'ascii') + b"\r\n")

            if b'Password:' in self.tn.read_until(b'Password:', timeout=read_timeout):
                # needed because of internal implementation details of the telnet server
                time.sleep(0.2)
                self.tn.write(bytes(password, 'ascii') + b"\r\n")

                if b'for more information.' in self.tn.read_until(b'Type "help()" for more information.', timeout=read_timeout):
                    # login succesful
                    from collections import deque
                    self.fifo = deque()
                    return

        raise PyboardError('Failed to establish a telnet connection with the board')

    def __del__(self):
        self.close()

    def close(self):
        try:
            self.tn.close()
        except:
            # the telnet object might not exist yet, so ignore this one
            pass

    def read(self, size=1):
        while len(self.fifo) < size:
            timeout_count = 0
            data = self.tn.read_eager()
            if len(data):
                self.fifo.extend(data)
                timeout_count = 0
            else:
                time.sleep(0.25)
                if self.read_timeout is not None and timeout_count > 4 * self.read_timeout:
                    break
                timeout_count += 1

        data = b''
        while len(data) < size and len(self.fifo) > 0:
            data += bytes([self.fifo.popleft()])
        return data

    def write(self, data):
        self.tn.write(data)
        return len(data)

    def inWaiting(self):
        n_waiting = len(self.fifo)
        if not n_waiting:
            data = self.tn.read_eager()
            self.fifo.extend(data)
            return len(data)
        else:
            return n_waiting

class Pyboard:
    def __init__(self, device, baudrate=115200, user='micro', password='python', wait=0, rawdelay=0):
        global _rawdelay
        _rawdelay = rawdelay
        if device and device[0].isdigit() and device[-1].isdigit() and device.count('.') == 3:
            # device looks like an IP address
            self.serial = TelnetToSerial(device, user, password, read_timeout=10)
        else:
            import serial
            delayed = False
            for attempt in range(wait + 1):
                try:
                    self.serial = serial.Serial(device, baudrate=baudrate, interCharTimeout=1)
                    break
                except (OSError, IOError): # Py2 and Py3 have different errors
                    if wait == 0:
                        continue
                    if attempt == 0:
                        sys.stdout.write(f'Waiting {wait} seconds for pyboard ')
                        delayed = True
                time.sleep(1)
                sys.stdout.write('.')
                sys.stdout.flush()
            else:
                if delayed:
                    print('')
                raise PyboardError('failed to access ' + device)
            if delayed:
                print('')

    def close(self):
        self.serial.close()

    def read_until(self, min_num_bytes, ending, timeout=10, data_consumer=None):
        data = self.serial.read(min_num_bytes)
        if data_consumer:
            data_consumer(data)
        timeout_count = 0
        while True:
            if data.endswith(ending):
                break
            elif self.serial.inWaiting() > 0:
                new_data = self.serial.read(1)
                data = data + new_data
                if data_consumer:
                    data_consumer(new_data)
                timeout_count = 0
            else:
                timeout_count += 1
                if timeout is not None and timeout_count >= 100 * timeout:
                    break
                time.sleep(0.01)
        return data

    def send_ctrl_a(self):
        self.serial.write(b'\r\x01') # ctrl-A: enter raw REPL

    def send_ctrl_b(self):
        self.serial.write(b'\r\x02') # ctrl-B: exit raw REPL

    def send_ctrl_c(self):
        self.serial.write(b'\r\x03') # ctrl-C twice: interrupt any running program
        time.sleep(0.1)
        self.serial.write(b'\x03')
        time.sleep(0.1)

    def send_ctrl_d(self):
        self.serial.write(b'\r\x04') # ctrl-D: soft reset

    def enter_raw_repl(self):
        # Brief delay before sending RAW MODE char if requests
        if _rawdelay > 0:
            time.sleep(_rawdelay)

        # ctrl-C twice: interrupt any running program
        self.serial.write(b'\r\x03')
        time.sleep(0.1)
        self.serial.write(b'\x03')
        time.sleep(0.1)

        # flush input (without relying on serial.flushInput())
        n = self.serial.inWaiting()
        while n > 0:
            self.serial.read(n)
            n = self.serial.inWaiting()

        for retry in range(0, 5): 
            self.serial.write(b'\r\x01') # ctrl-A: enter raw REPL
            data = self.read_until(1, b'raw REPL; CTRL-B to exit\r\n>')
            if data.endswith(b'raw REPL; CTRL-B to exit\r\n>'):
                break
            else:
                if retry >= 4:
                    print(data)
                    raise PyboardError('could not enter raw repl')
                time.sleep(0.2)

        self.serial.write(b'\x04') # ctrl-D: soft reset
        data = self.read_until(1, b'soft reboot\r\n')
        if not data.endswith(b'soft reboot\r\n'):
            print(data)
            raise PyboardError('could not enter raw repl')
        # By splitting this into 2 reads, it allows boot.py to print stuff,
        # which will show up after the soft reboot and before the raw REPL.
        # Modification from original pyboard.py below:
        #   Add a small delay and send Ctrl-C twice after soft reboot to ensure
        #   any main program loop in main.py is interrupted.
        time.sleep(0.5)
        self.serial.write(b'\x03')
        time.sleep(0.1)           # (slight delay before second interrupt
        self.serial.write(b'\x03')
        # End modification above.
        data = self.read_until(1, b'raw REPL; CTRL-B to exit\r\n')
        if not data.endswith(b'raw REPL; CTRL-B to exit\r\n'):
            print(data)
            raise PyboardError('could not enter raw repl')

    def exit_raw_repl(self):
        self.serial.write(b'\r\x02') # ctrl-B: enter friendly REPL

    def follow(self, timeout, data_consumer=None):
        # wait for normal output
        data = self.read_until(1, b'\x04', timeout=timeout, data_consumer=data_consumer)
        if not data.endswith(b'\x04'):
            raise PyboardError('timeout waiting for first EOF reception')
        data = data[:-1]

        # wait for error output
        data_err = self.read_until(1, b'\x04', timeout=timeout)
        if not data_err.endswith(b'\x04'):
            raise PyboardError('timeout waiting for second EOF reception')
        data_err = data_err[:-1]

        # return normal and error output
        return data, data_err

    def exec_raw_no_follow(self, command):
        if isinstance(command, bytes):
            command_bytes = command
        else:
            command_bytes = bytes(command, encoding='utf8')

        # check we have a prompt
        data = self.read_until(1, b'>')
        if not data.endswith(b'>'):
            raise PyboardError('could not enter raw repl')

        # write command
        for i in range(0, len(command_bytes), 256):
            self.serial.write(command_bytes[i:min(i + 256, len(command_bytes))])
            time.sleep(0.01)
        self.serial.write(b'\x04')

        # check if we could exec command
        data = self.serial.read(2)
        if data != b'OK':
            raise PyboardError('could not exec command')

    def exec_raw(self, command, timeout=10, data_consumer=None):
        self.exec_raw_no_follow(command)
        return self.follow(timeout, data_consumer)

    def eval(self, expression):
        ret = self.exec_(f'print({expression})')
        ret = ret.strip()
        return ret

    def exec_(self, command, stream_output=False):
        data_consumer = None
        if stream_output:
            data_consumer = stdout_write_bytes
        ret, ret_err = self.exec_raw(command, data_consumer=data_consumer)
        if ret_err:
            raise PyboardError('exception', ret, ret_err)
        return ret

    def execfile(self, filename, stream_output=False):
        with open(filename, 'rb') as f:
            pyfile = f.read()
        return self.exec_(pyfile, stream_output=stream_output)

    def get_time(self):
        t = str(self.eval('pyb.RTC().datetime()'), encoding='utf8')[1:-1].split(', ')
        return int(t[4]) * 3600 + int(t[5]) * 60 + int(t[6])

# in Python2 exec is a keyword so one must use "exec_"
# but for Python3 we want to provide the nicer version "exec"
setattr(Pyboard, "exec", Pyboard.exec_)

def execfile(filename, device='/dev/ttyACM0', baudrate=115200, user='micro', password='python'):
    pyb = Pyboard(device, baudrate, user, password)
    pyb.enter_raw_repl()
    output = pyb.execfile(filename)
    stdout_write_bytes(output)
    pyb.exit_raw_repl()
    pyb.close()

# def main():
#     import argparse
#     cmd_parser = argparse.ArgumentParser(description='Run scripts on the pyboard.')
#     cmd_parser.add_argument('--device', default='/dev/ttyACM0', help='the serial device or the IP address of the pyboard')
#     cmd_parser.add_argument('-b', '--baudrate', default=115200, help='the baud rate of the serial device')
#     cmd_parser.add_argument('-u', '--user', default='micro', help='the telnet login username')
#     cmd_parser.add_argument('-p', '--password', default='python', help='the telnet login password')
#     cmd_parser.add_argument('-c', '--command', help='program passed in as string')
#     cmd_parser.add_argument('-w', '--wait', default=0, type=int, help='seconds to wait for USB connected board to become available')
#     cmd_parser.add_argument('--follow', action='store_true', help='follow the output after running the scripts [default if no scripts given]')
#     cmd_parser.add_argument('files', nargs='*', help='input files')
#     args = cmd_parser.parse_args()

#     def execbuffer(buf):
#         try:
#             pyb = Pyboard(args.device, args.baudrate, args.user, args.password, args.wait)
#             pyb.enter_raw_repl()
#             ret, ret_err = pyb.exec_raw(buf, timeout=None, data_consumer=stdout_write_bytes)
#             pyb.exit_raw_repl()
#             pyb.close()
#         except PyboardError as er:
#             print(er)
#             sys.exit(1)
#         except KeyboardInterrupt:
#             sys.exit(1)
#         if ret_err:
#             stdout_write_bytes(ret_err)
#             sys.exit(1)

#     if args.command is not None:
#         execbuffer(args.command.encode('utf-8'))

#     for filename in args.files:
#         with open(filename, 'rb') as f:
#             pyfile = f.read()
#             execbuffer(pyfile)

#     if args.follow or (args.command is None and len(args.files) == 0):
#         try:
#             pyb = Pyboard(args.device, args.baudrate, args.user, args.password, args.wait)
#             ret, ret_err = pyb.follow(timeout=None, data_consumer=stdout_write_bytes)
#             pyb.close()
#         except PyboardError as er:
#             print(er)
#             sys.exit(1)
#         except KeyboardInterrupt:
#             sys.exit(1)
#         if ret_err:
#             stdout_write_bytes(ret_err)
#             sys.exit(1)



BUFFER_SIZE = 512  # Amount of data to read or write to the serial port at a time.
# This is kept small because small chips and USB to serial
# bridges usually have very small buffers.


class DirectoryExistsError(Exception):
    pass


class Files(object):
    """Class to interact with a MicroPython board files over a serial connection.
    Provides functions for listing, uploading, and downloading files from the
    board's filesystem.
    """
    __raw_repl_on: bool = False

    def __init__(self, pyboard: Pyboard):
        """Initialize the MicroPython board files class using the provided pyboard
        instance.  In most cases you should create a Pyboard instance (from
        pyboard.py) which connects to a board over a serial connection and pass
        it in, but you can pass in other objects for testing, etc.
        """
        self._pyboard = pyboard

    def is_raw_repl_on(self):
        return self.__raw_repl_on

    def send_ctrl_a(self):
        self._pyboard.send_ctrl_a() # ctrl-A: enter raw REPL

    def send_ctrl_b(self):
        self._pyboard.send_ctrl_b() # ctrl-B: exit raw REPL

    def send_ctrl_c(self):
        self._pyboard.send_ctrl_c() # ctrl-C twice: interrupt any running program

    def send_ctrl_d(self):
        self._pyboard.send_ctrl_d()  # ctrl-D: soft reset

    def handle_traceback(self, e: Exception):
        message = e.args[2].decode('utf-8')
        oserror = message.split('OSError:')

        if len(oserror) == 2:
            reason = oserror[1].strip()

            if reason == '-2':
                reason = '[Errno -2] EUNKNOWN'
            if reason == '39':
                reason = '[Errno 39] ENEPTY'
        else:
            reason = 'Traceback (most recent call last):'
            traceback = message.split(reason)
            
            if len(traceback) == 2:
                for call in traceback[1][:-2].split('\\r\\n'):
                    reason += f'{call}\n'

        raise Exception(reason.strip())

    def ls(self, directory="/", long_format=False, recursive=True):
        """List the contents of the specified directory (or root if none is
        specified).  Returns a list of strings with the names of files in the
        specified directory.  If long_format is True then a list of 2-tuples
        with the name and size (in bytes) of the item is returned.  Note that
        it appears the size of directories is not supported by MicroPython and
        will always return 0 (i.e. no recursive size computation).
        """

        # Disabling for now, see https://github.com/adafruit/ampy/issues/55.
        # # Make sure directory ends in a slash.
        # if not directory.endswith("/"):
        #     directory += "/"

        # Make sure directory starts with slash, for consistency.
        # if not directory.startswith("/"):
        #     directory = "/" + directory

        command = """\
                try:        
                    import os
                except ImportError:
                    import uos as os\n"""

        if recursive:
            command += """\
                def listdir(directory):
                    result = set()

                    def _listdir(dir_or_file):
                        try:
                            # if its a directory, then it should provide some children.
                            children = os.listdir(dir_or_file)
                        except OSError:                        
                            # probably a file. run stat() to confirm.
                            os.stat(dir_or_file)
                            result.add(dir_or_file) 
                        else:
                            # probably a directory, add to result if empty.
                            if children:
                                # queue the children to be dealt with in next iteration.
                                for child in children:
                                    # create the full path.
                                    if dir_or_file == '/':
                                        next = dir_or_file + child
                                    else:
                                        next = dir_or_file + '/' + child
                                    
                                    _listdir(next)
                            else:
                                result.add(dir_or_file)                     

                    _listdir(directory)
                    return sorted(result)\n"""
        else:
            command += """\
                def listdir(directory):
                    if directory == '/':                
                        return sorted([directory + f for f in os.listdir(directory)])
                    else:
                        return sorted([directory + '/' + f for f in os.listdir(directory)])\n"""

        # Execute os.listdir() command on the board.
        if long_format:
            command += f"""
                r = []
                for f in listdir('{directory}'):
                    size = os.stat(f)[6]                    
                    r.append(f'{{f}} - {{size}}b')
                print(r)
            """
        else:
            command += f"""
                print(listdir('{directory}'))
            """
        
        try:
            self.__raw_repl_on = True
            self._pyboard.enter_raw_repl()
            output = self._pyboard.exec_(textwrap.dedent(command))
        except Exception as e:
            self.handle_traceback(e)
        finally:
            self._pyboard.exit_raw_repl()
            self.__raw_repl_on = False

        # Parse the result list and return it.
        return ast.literal_eval(output.decode("utf-8"))

    def mkdir(self, directory, exists_okay=True):
        """Create the specified directory.  Note this cannot create a recursive
        hierarchy of directories, instead each one should be created separately.
        """
        # Execute os.mkdir command on the board.
        command = f"""
            try:
                import os
            except ImportError:
                import uos as os
            os.mkdir('{directory}')
        """
        
        try:
            self.__raw_repl_on = True
            self._pyboard.enter_raw_repl()
            self._pyboard.exec_(textwrap.dedent(command))
        except Exception as e:
            if exists_okay == False:
                self.handle_traceback(e)
        finally:
            self._pyboard.exit_raw_repl()
            self.__raw_repl_on = False

    def put(self, filename, data):
        """Create or update the specified file with the provided data.
        """
        # Open the file for writing on the board and write chunks of data.

        if filename.startswith('/'):
            filename = filename[1:]

        print(f'+ {filename}', end='', flush=True)
        size = len(data)

        try:
            self.__raw_repl_on = True
            self._pyboard.enter_raw_repl()
            self._pyboard.exec_(f"f = open('{filename}', 'wb')")
            # Loop through and write a buffer size chunk of data at a time.
            for i in range(0, size, BUFFER_SIZE):
                chunk_size = min(BUFFER_SIZE, size - i)
                chunk = repr(data[i : i + chunk_size])
                # Make sure to send explicit byte strings (handles python 2 compatibility).
                if not chunk.startswith("b"):
                    chunk = "b" + chunk
                self._pyboard.exec_(f"f.write({chunk})")
            self._pyboard.exec_("f.close()")
        except Exception as e:
            print(' [x]')
            self.handle_traceback(e)
        finally:
            self._pyboard.exit_raw_repl()
            self.__raw_repl_on = False

        print(f' - {size}b [✓]')
        return size

    def get(self, filename):
        """Retrieve the contents of the specified file and return its contents
        as a byte string.
        """
        # Open the file and read it a few bytes at a time and print out the
        # raw bytes.  Be careful not to overload the UART buffer so only write
        # a few bytes at a time, and don't use print since it adds newlines and
        # expects string data.
        command = f"""
            import sys
            import ubinascii
            with open('{filename}', 'rb') as infile:
                while True:
                    result = infile.read({BUFFER_SIZE})
                    if result == b'':
                        break
                    len = sys.stdout.write(ubinascii.hexlify(result))
        """
        print(f'↓ {filename}', end='', flush=True)
        
        try:
            self.__raw_repl_on = True
            self._pyboard.enter_raw_repl()
            output = self._pyboard.exec_(textwrap.dedent(command))
        except PyboardError as e:
            print(' [x]')
            self.handle_traceback(e)
        finally:
            self._pyboard.exit_raw_repl()
            self.__raw_repl_on = False

        print(f' {int(len(output) / 2)}b [✓]')
        return binascii.unhexlify(output)

    def rm(self, filename):
        """Remove the specified file or directory."""
        command = f"""
            try:
                import os
            except ImportError:
                import uos as os
            os.remove('{filename}')
        """
        print(f'– {filename}', end='')
        
        try:
            self.__raw_repl_on = True
            self._pyboard.enter_raw_repl()
            self._pyboard.exec_(textwrap.dedent(command))
        except Exception as e:
            print(' [x]')
            self.handle_traceback(e)
        finally:
            self._pyboard.exit_raw_repl()
            self.__raw_repl_on = False
        
        print(' [✓]')

    def rmdir(self, directory, missing_okay=False):
        """Forcefully remove the specified directory and all its children."""
        # Build a script to walk an entire directory structure and delete every
        # file and subfolder.  This is tricky because MicroPython has no os.walk
        # or similar function to walk folders, so this code does it manually
        # with recursion and changing directories.  For each directory it lists
        # the files and deletes everything it can, i.e. all the files.  Then
        # it lists the files again and assumes they are directories (since they
        # couldn't be deleted in the first pass) and recursively clears those
        # subdirectories.  Finally when finished clearing all the children the
        # parent directory is deleted.
        command = f"""
            try:
                import os
            except ImportError:
                import uos as os
            def rmdir(directory):
                os.chdir(directory)
                for f in os.listdir():
                    try:
                        os.remove(f)
                    except OSError:
                        pass
                for f in os.listdir():
                    rmdir(f)
                os.chdir('..')
                os.rmdir(directory)
            rmdir('{directory}')
        """
        print(f'– {directory}', end='')

        try:
            self.__raw_repl_on = True
            self._pyboard.enter_raw_repl()
            self._pyboard.exec_(textwrap.dedent(command))
        except Exception as e:
            print(' [x]')
            self.handle_traceback(e)
        finally:
            self._pyboard.exit_raw_repl()
            self.__raw_repl_on = False

        print(' [✓]')

    def run_on_board(self, filename, wait_output=True, stream_output=True):
        """Run the provided script and return its output.  If wait_output is True
        (default) then wait for the script to finish and then return its output,
        otherwise just run the script and don't wait for any output.
        If stream_output is True(default) then return None and print outputs to
        stdout without buffering.
        """
        command = textwrap.dedent(f'exec(open("{filename}").read())')
        output = None

        try:
            self.__raw_repl_on = True
            self._pyboard.enter_raw_repl()

            if stream_output:
                self._pyboard.exec_(command, stream_output=True)
            elif wait_output:
                # Run the file and wait for output to return.
                output = self._pyboard.exec_(command)
            else:
                # Read the file and run it using lower level pyboard functions that
                # won't wait for it to finish or return output.
                self._pyboard.exec_raw_no_follow(command)
        except Exception as e:
            self.handle_traceback(e)
        finally:
            self._pyboard.exit_raw_repl()
            self.__raw_repl_on = False

        return output

    def exec(self, command):
        try:
            self.__raw_repl_on = True
            self._pyboard.enter_raw_repl()
            output = self._pyboard.exec_(textwrap.dedent(command), stream_output=True)
        except Exception as e:
            self.handle_traceback(e)
        finally:
            self._pyboard.exit_raw_repl()
            self.__raw_repl_on = False

        return output


print('Welcome to picowatch lib.')
pico = False

while not pico:
    print('-' * 30)
    device = input('Port: ').strip()
    baudrate = input('Baudrate (115200): ').strip() or 115200

    try:
        pico = Files(Pyboard(device=device, baudrate=baudrate))
        print(f'Connected to device: {device} at a baudrate of: {baudrate}')
        print('-' * 30)
    except Exception as e:
        print(str(e))
    
pico.send_ctrl_c()
WATCHING_DIRECTORY = './'

def upload(source: str = '', destination: str = ''):
    real_source = os.path.join(WATCHING_DIRECTORY, *source.split('/'))

    if not destination:
        destination = source

    destination = '/'.join(destination.split('\\'))

    try:
        if os.path.isdir(real_source):
            for root, dirs, files in os.walk(real_source, followlinks=True):
                droot = '/'.join(root.replace(WATCHING_DIRECTORY, '').split(os.sep))
                
                for dir in dirs:
                    pico.mkdir('/'.join([droot, dir]), exists_okay=True)
                
                for filename in files:
                    with open(os.path.join(root, filename), 'rb') as fh:
                        pico.put('/'.join([droot, filename]), fh.read())
                    
                    time.sleep(.5)
        elif os.path.exists(real_source):
            with open(real_source, 'rb') as fh:
                pico.put(destination, fh.read())

            time.sleep(.5)
    except Exception as e:
        print(str(e))


def download(source: str = '/'):
    if not source.startswith('/'):
        source = f'/{source}'
    
    if len(source) > 1 and source.endswith('/'):
        source = source[:-1]

    try:
        for filename in pico.ls(directory=source, long_format=False, recursive=True):
            filename = filename[1:]
            
            if filename.startswith('.'):
                continue

            if os.path.dirname(filename):
                os.makedirs(os.path.dirname(filename), mode=777, exist_ok=True)

            with open(os.path.join(WATCHING_DIRECTORY, *filename.split('/')), 'wb') as fh:
                fh.write(pico.get(filename))
            
            time.sleep(.5)
    except Exception as e:
        print(str(e))


def contents(filename: str):
    try:
        for ln in pico.get(filename).decode('utf-8').split('\n'):
            print(ln)
    except Exception as e:
        print(str(e))


def delete(source: str, is_directory: bool = False):
    try:
        if is_directory:
            for filename in pico.ls(directory=source, long_format=False, recursive=True):
                if filename.startswith('/'):
                    filename = filename[1:]

                pico.rm(filename)
            
            try:
                for filename in pico.ls(directory=source, long_format=False, recursive=True):
                    if filename.startswith('/'):
                        filename = filename[1:]

                    if not filename.endswith('/'):
                        filename += '/'

                    pico.rm(filename)
            except:
                pass
        else:
            pico.rm(source)
    except Exception as e:
        print(str(e))


def ls(source: str = '/'):
    try:
        if len(source) > 1 and source.endswith('/'):
            source = source[:-1]

        for filename in pico.ls(directory=source, long_format=True, recursive=True):
            if filename.startswith('/'):
                filename = filename[1:]

            if len(filename) > 6:
                print('→', filename)
    except Exception as e:
        print(str(e))


def launch(filename: str = 'main.py'):
    try:
        pico.run_on_board(filename)
    except Exception as e:
        print(str(e))


sessions = {'deleted': set(), 'modified': set()}

def on_modified_callback(event):
    if event.is_directory == True:
        return

    source = event.src_path.replace(WATCHING_DIRECTORY, '').replace('\\', '/')
    sessions['modified'].add(source)


def on_deleted_callback(event):
    source = event.src_path.replace(WATCHING_DIRECTORY, '').replace('\\', '/')

    if event.is_directory == True and not source.endswith('/'):
        source += '/'
    elif len(source.split('.')) == 1:
        source += '/'
        
    sessions['deleted'].add(source)


def watchdog_callback():
    for source in sessions['deleted']:
        delete(source)

    for source in sessions['modified']:
        upload(source)

    sessions['deleted'] = set()
    sessions['modified'] = set()
    

signal.signal(signal.SIGINT, lambda a, b: pico.send_ctrl_c())
watchdog_event = PatternMatchingEventHandler(
    patterns = ['*'], 
    ignore_patterns = None, 
    ignore_directories = False, 
    case_sensitive = True
)
watchdog_event.on_modified = on_modified_callback
watchdog_event.on_deleted = on_deleted_callback

watchdog = Observer()
watchdog.schedule(watchdog_event, path = WATCHING_DIRECTORY, recursive = True)
watchdog.start()


try:
    while True:
        try:
            print('>>> ', end='')
            message = input().strip()

            while pico.is_raw_repl_on():
                time.sleep(.1)

            match message.split(' '):
                case ['0' | 'exit']:
                    sys.exit()
                case ['reboot' | 'reset']:
                    pico.send_ctrl_d()
                case ['ls' | 'stat', *source]:
                    ls(source[0] if source else '/')
                case ['cat' | 'open' | 'contents', source]:
                    contents(source)
                case ['del' | 'rm' | 'delete', source]:
                    delete(source)
                case ['del*' | 'rm*' | 'rmdir' | 'delete*', source]:
                    delete(source, is_directory=True)
                case ['format']:
                    delete('/', is_directory=True)
                case ['upl' | 'upload' | 'update', source]:
                    upload(source)
                case ['download' | 'backup', source]:
                    download(source)
                case ['' | 'save' | 'commit']:
                    watchdog_callback()
                case ['status' | 'staged']:
                    for filename in sessions['deleted']:
                        print('–', filename)

                    for filename in sessions['modified']:
                        print('+', filename)
                case ['cancel' | 'unstaged']:
                    sessions['deleted'] = set()
                    sessions['modified'] = set()
                case _:
                    if message.startswith('./'):
                        launch(message[2:])
                    elif message:
                        print(f'"{message}" is not recognized.')
        except Exception as e:
            print(str(e))
except KeyboardInterrupt:
    watchdog.stop()

watchdog.join()