Example #1
0
 def test_can_build_solution_from_letters_dictionary(self):
     crossword = Crossword()
     crossword.size(3)
     letters = {}
     letters[0, 0] = "A"
     letters[1, 0] = "B"
     letters[2, 0] = ""
     letters[0, 1] = ""
     letters[1, 1] = "C"
     letters[2, 1] = "D"
     letters[0, 2] = "E"
     letters[1, 2] = "F"
     letters[2, 2] = "G"
     crossword.build_solution(letters)
     self.assertEquals(crossword.across_solutions[0], "AB")
     self.assertEquals(crossword.across_solutions[2], "EFG")
     self.assertEquals(crossword.down_solutions[0], "BCF")
Example #2
0
class Application:
    def __init__(self, screen):
        self.sel = selectors.DefaultSelector()
        self.screen = screen

        self.is_running = False

        #curses.raw() # disable special keys and stuff (such as ctrl-c)
        self.screen.nodelay(True)  # disable blocking on getch()
        curses.curs_set(False)  # hide cursor
        curses.mousemask(curses.ALL_MOUSE_EVENTS)  # enable mouse interaction
        curses.nonl()  # don't translate KEY_RETURN into '\r\n'

        self.screen.clear()

        # create server for remote control
        self.mi = ManagementInterface(1234, self.sel)
        log.info("local address: {}".format(self.mi.get_local_addresses()))

        self.mi.register_handler('quit', self.exit_app_by_packet)
        self.mi.register_handler('reset', lambda _: self.reset())
        self.mi.register_handler('show_popup', self.show_popup_from_packet)
        self.mi.register_handler('ping', lambda _: None)  # dummy command

        self.widget_mgr = WidgetManager(self)

        # register key handler
        self.sel.register(sys.stdin, selectors.EVENT_READ, self.handle_input)

        with open('puzzle.cfg', 'r') as puzzle_cfg:
            cfg = json.load(puzzle_cfg)
            log.info("using configuration: {}".format(cfg))
            h, w = screen.getmaxyx()
            self.puzzle = Crossword(self, Vector(10, 1), Vector(w - 10, h - 2),
                                    cfg)
            self.widget_mgr.add(self.puzzle)
            self.widget_mgr.focus = self.puzzle

        self.puzzle.resize_to_contents()

        # center in middle of screen (also take progress bar into account)
        ps = self.puzzle.size()
        self.puzzle.move(Vector(int((w - ps.x) / 2), int((h - ps.y + 4) / 2)))

        self.progress_bar = ProgressBar(self,
                                        self.puzzle.pos() - Vector(0, 4),
                                        Vector(self.puzzle.size().x, 4),
                                        'Lösungsfortschritt:')
        self.puzzle.progress_bar = self.progress_bar
        self.puzzle.solved_callback = self.on_crossword_solved

        self.door_panel = DoorPanel(self)
        self.door_panel.center_in(self.screen)
        self.widget_mgr.add(self.door_panel)
        self.door_panel.visible = False
        #self.widget_mgr.focus = self.door_panel

        self.shooting_range = ShootingRange(self)
        self.widget_mgr.add(self.shooting_range)
        self.sel.register(self.shooting_range.target.shots_queue_available,
                          selectors.EVENT_READ, self.handle_shot)
        self.widget_mgr.focus = self.shooting_range
        """
        self.widget_mgr.show_popup('Dies ist der Titel',
                "asdfa sfasdfdsaf;dsa kfsa;dkfjdsa;if jsa;ifjsa dfijdsfoisdhaf " +'%'*40+ " uhsaif usahd end of first line\nsecond line here\nand a third " + "#"*250,
                lambda b: log.info('selected {}'.format(b)), ['foo', 'bar', 'baz'])
                """

    def __del__(self):
        self.exit()

    def handle_input(self, stdin):
        k = self.screen.getch()
        if k >= 0:
            if k == curses.KEY_F1 or k == curses.KEY_F2:
                self.widget_mgr.show_single_popup(
                    'Hilfe',
                    'TODO: Hier sollte wohl etwas Hilfe zum Puzzle (bzw. einfach zur Bedienung) hinkommen.'
                )
            elif k == curses.KEY_F12:
                self.show_about()
            elif k == curses.KEY_F11 or k == curses.KEY_F9:
                self.show_admin_screen()
            else:
                if not self.widget_mgr.handle_input(k):
                    log.info("unhandled key '{}'".format(k))

    def handle_shot(self, _):
        self.shooting_range.target.shots_queue_available.clear()
        while not self.shooting_range.target.shots_queue.empty():
            self.shooting_range.handle_shot(
                self.shooting_range.target.shots_queue.get())

    def show_about(self):
        self.widget_mgr.show_single_popup(
            'Kreuzworträtsel', """Geschrieben von Samuel Bryner

Diese Software ist frei verfügbar unter der GPL. Quellcode unter
https://github.com/iliis/crossword
""")

    def show_admin_screen(self):
        self.widget_mgr.show_single_popup(
            'Admin',
            'Serial Port: {}\n\n'.format(self.shooting_range.target.ser.name) +
            'Local Address:\n{}\n'.format('\n'.join(
                ' - {}'.format(a) for a in self.mi.get_local_addresses())) +
            'Local Port: {}\n'.format(self.mi.port) +
            'Remote Control Connections:\n{}\n'.format('\n'.join(
                ' - {}'.format(c.getpeername()) for c in self.mi.connections)),
            callback=self._admin_screen_cb,
            buttons=['CLOSE', 'AUTOFILL', 'RESET ALL', 'EXIT APP'])

    def _admin_screen_cb(self, button):
        if button == 'EXIT APP':
            log.info("Exiting application through admin panel.")
            self.exit()
        elif button == 'RESET ALL':
            self.reset()
        elif button == 'AUTOFILL':
            self.puzzle.autofill()

    def exit_app_by_packet(self, packet):
        log.info("Exiting application trough remote command.")
        self.exit()

    def exit(self):
        self.is_running = False
        self.shooting_range.target.is_running = False

    def show_popup_from_packet(self, packet):
        if not 'title' in packet or not 'text' in packet:
            raise ValueError(
                "Invalid command: missing 'title' or 'text' field.")

        if 'buttons' in packet:
            buttons = packet['buttons']
        else:
            buttons = ['OK']

        self.widget_mgr.show_single_popup(packet['title'],
                                          packet['text'],
                                          buttons=buttons)

    def on_crossword_solved(self, _):
        self.puzzle.visible = False
        self.door_panel.visible = True
        self.widget_mgr.focus = self.door_panel

    def reset(self):
        log.info("Resetting application!")
        self.screen.clear()
        self.puzzle.reset()

        self.door_panel.reset()
        self.door_panel.visible = False

        self.widget_mgr.focus = self.puzzle

    def run(self):
        #ser.write(b'crossword running')
        self.is_running = True

        while self.is_running:
            self.widget_mgr.render()
            events = self.sel.select()

            for key, mask in events:
                callback = key.data
                callback(key.fileobj)
Example #3
0
class Application:
    def __init__(self, screen):
        self.sel = selectors.DefaultSelector()
        self.screen = screen

        self.is_running = False

        # optionally pass different configuration file (useful for debugging)
        if len(sys.argv) > 1:
            app_cfg_path = sys.argv[1]
        else:
            app_cfg_path = os.path.join(
                os.path.dirname(os.path.realpath(__file__)), 'app.cfg')

        with open(app_cfg_path, 'r') as app_cfg:
            self.cfg = json.load(app_cfg)
            log.info("using application configuration: {}".format(self.cfg))

            if not self.cfg['cheats']:
                # ignore CTRL+Z/V keybinding
                log.info("disabling SIGINT")
                signal.signal(signal.SIGINT, signal.SIG_IGN)

        #curses.raw() # disable special keys and stuff (such as ctrl-c)
        self.screen.nodelay(True)  # disable blocking on getch()
        curses.curs_set(False)  # hide cursor
        curses.mousemask(curses.ALL_MOUSE_EVENTS)  # enable mouse interaction
        curses.nonl()  # don't translate KEY_RETURN into '\r\n'

        self.screen.clear()

        # make sure display is big enough
        H, W = self.screen.getmaxyx()
        log.info("Screen Size: {} cols by {} rows".format(W, H))

        if W < 102 or H < 39:
            raise Exception(
                "Screen is too small: {} rows by {} columns, but we need at least 39 by 102.\n"
                .format(H, W) +
                "Try a smaller font size or increasing the resolution of your terminal emulator."
            )

        # create server for remote control
        self.mi = ManagementInterface(1234, self.sel)
        log.info("local address: {}".format(self.mi.get_local_addresses()))

        self.mi.register_handler('quit', self.exit_app_by_packet)
        self.mi.register_handler('shutdown', self.shutdown)
        self.mi.register_handler('reset', lambda _: self.reset())
        self.mi.register_handler('show_popup', self.show_popup_from_packet)
        self.mi.register_handler('ping', lambda _: None)  # dummy command
        self.mi.register_handler('set_time',
                                 lambda p: self.set_timeout(p['timeout']))
        self.mi.register_handler('show_shooting_range',
                                 lambda _: self.show_shooting_range())
        self.mi.register_handler(
            'get_time',
            lambda p: self.mi.reply_success(p, self.remaining_time()))
        self.mi.register_handler('restore_saved_state',
                                 self.restore_backup_by_packet)
        self.mi.register_handler('memory_dump', lambda p: self.memory_dump())
        self.mi.register_handler('wakeup', lambda p: self.wakeup_screen())

        self.mi.new_connection_handler = self.new_connection_handler

        self.widget_mgr = WidgetManager(self)

        self.TIMEOUT = self.cfg["game_timeout"]  #60*60
        self.timeout_timer = WaitableTimer(self.sel, self.TIMEOUT,
                                           self.on_timeout)
        self.set_timeout(self.TIMEOUT)

        # register key handler
        self.sel.register(sys.stdin, selectors.EVENT_READ, self.handle_input)

        puzzle_filename = os.path.join(
            os.path.dirname(os.path.realpath(__file__)), 'puzzle.cfg')
        with open(puzzle_filename, 'r', encoding="utf-8") as puzzle_cfg:
            pcfg = json.load(puzzle_cfg)
            log.info("using puzzle configuration: {}".format(pcfg))
            h, w = screen.getmaxyx()
            self.puzzle = Crossword(self, Vector(10, 1), Vector(w - 10, h - 2),
                                    pcfg)
            self.widget_mgr.show(self.puzzle)

        self.puzzle.resize_to_contents()
        H, W = self.puzzle.screen.getmaxyx()
        log.info("Puzzle Size: {} x {}".format(W, H))

        # center in middle of screen (also take progress bar into account)
        ps = self.puzzle.size()
        try:
            self.puzzle.move(
                Vector(int((w - ps.x) / 2), int((h - ps.y + 6) / 2)))
        except Exception as e:
            raise Exception(
                "Failed to move curses window. This can happen if your screen is too small!\nMaybe you forgot to switch to fullscreen?"
            )

        self.progress_bar = ProgressBar(self,
                                        self.puzzle.pos() - Vector(0, 5),
                                        Vector(self.puzzle.size().x, 5),
                                        'Lösungsfortschritt:')
        self.puzzle.progress_bar = self.progress_bar
        self.puzzle.solved_callback = self.on_crossword_solved

        self.door_panel = DoorPanel(self)
        self.door_panel.center_in(self.screen)
        self.door_panel.visible = False
        #self.widget_mgr.add(self.door_panel)

        self.shooting_range = ShootingRange(self)
        self.shooting_range.first_shot_callback = self.show_shooting_range
        self.shooting_range.closed_callback = self.on_shooting_range_closed

        if self.shooting_range.target is None:
            self.widget_mgr.show_popup(
                "Hallo", "Konnte keine Verbindung zum Reddot-Target aufbauen. "
                "Schiessstand ist deaktiviert.")
        else:
            self.sel.register(self.shooting_range.target.shots_queue_available,
                              selectors.EVENT_READ, self.handle_shot)
            self.sel.register(self.shooting_range.target.has_raised_exception,
                              selectors.EVENT_READ,
                              self.handle_exception_in_reddot_target)

        self.final_screen = FinalScreen(self)

        self.check_for_backup()

        self.periodic_backup_timer = WaitableTimer(self.sel, 10,
                                                   self.on_periodic_backup)
        self.periodic_backup_timer.start()

    def __del__(
        self
    ):  # TODO: this should be implemented using a context manager ('with')
        self.mi.delete()
        del self.mi
        self.exit()

    def set_timeout(self, seconds):
        if seconds <= 0:
            log.warn(
                "set timeout called with invalid timeout '{}', setting timeout to one second."
                .format(seconds))
            seconds = 1  # netagive or zero timeouts are not allowed
        self.TIMEOUT = seconds
        self.time_ends = time.time() + self.TIMEOUT
        self.timeout_timer.reset(
            self.TIMEOUT
        )  # stop any running timer (if any) and set new timeout
        self.timeout_timer.start()

    def on_timeout(self):
        log.info("main application timeout!")
        self.mi.send_packet({
            'event': 'main_timeout',
        })

        self.widget_mgr.remove(self.puzzle)
        self.widget_mgr.remove(self.shooting_range)
        self.widget_mgr.remove(self.door_panel)
        self.widget_mgr.show(self.final_screen)

        self.screen.clear()
        self.screen.refresh()
        self.widget_mgr.show_popup(
            "Zeit Abgelaufen",
            "Ihre Zeit ist leider rum. Bitte begeben Sie sich zum Ausgang.\nFreundlichst, Ihre Spielleitung"
        )
        self.widget_mgr.render()

        self.clear_backup()

    def show_static_crossword(self):
        log.info("showing crossword again")
        self.widget_mgr.remove_all()
        self.widget_mgr.show(self.puzzle)

    def handle_input(self, stdin):
        k = self.screen.get_wch()
        if k == curses.KEY_F1:
            self.show_help()
        elif k == curses.KEY_F12:
            self.show_about()
        elif k == curses.KEY_F9:
            if self.cfg["cheats"]:
                self.show_admin_screen()
            else:
                self.widget_mgr.show_input("Management", "Passwort:",
                                           self.show_admin_screen, True)
        else:
            if not self.widget_mgr.handle_input(k):
                log.info("unhandled key '{}'".format(k))

    def handle_shot(self, _):
        self.shooting_range.target.shots_queue_available.clear()
        while not self.shooting_range.target.shots_queue.empty():
            self.shooting_range.handle_shot(
                self.shooting_range.target.shots_queue.get())

    def show_about(self):
        self.widget_mgr.show_popup(
            'Kreuzworträtsel', """Geschrieben von Samuel Bryner:

Diese Software ist frei verfügbar unter der GPL. Quellcode unter
https://github.com/iliis/crossword
""")

    def show_admin_screen(self, pw=None):
        if pw == self.cfg["admin_pw"] or self.cfg["cheats"]:

            ser_port = "not connected"
            if self.shooting_range.target is not None:
                ser_port = self.shooting_range.target.ser.name

            self.widget_mgr.show_popup(
                'Admin',
                'Version {}\nLast Update: {}\n\n'.format(
                    get_version(), get_version_date()) +
                'Serial Port: {}\n\n'.format(ser_port) +
                'Local Address:\n{}\n'.format('\n'.join(
                    ' - {}'.format(a)
                    for a in self.mi.get_local_addresses())) +
                'Local Port: {}\n\n'.format(self.mi.port) +
                'Remote Control Connections:\n{}\n'.format('\n'.join(
                    ' - {}'.format(c.getpeername())
                    for c in self.mi.connections)),
                callback=self._admin_screen_cb,
                buttons=[
                    'CLOSE', 'LOAD BACKUP', 'AUTOFILL', 'SHOW SRANGE',
                    'RESET ALL', 'EXIT APP'
                ])
        else:
            self.widget_mgr.show_popup(
                'Passwort Falsch',
                'Die Management-Konsole ist nur für die Spielleitung gedacht, sorry.'
            )

    def _admin_screen_cb(self, button):
        if button == 'EXIT APP':
            log.info("Exiting application through admin panel.")
            self.exit()
        elif button == 'RESET ALL':
            self.reset()
        elif button == 'AUTOFILL':
            self.puzzle.autofill()
        elif button == 'SHOW SRANGE':
            self.show_shooting_range()
        elif button == 'LOAD BACKUP':
            if not self.restore_backup():
                self.widget_mgr.show_popup(
                    'Backup wiederhestellen fehlgeschlagen',
                    'Konnte kein Backup laden. Kontrollier das log für weitere Fehler. Gibt es überhaupt ein Backup?'
                )
        elif button == 'CLOSE':
            pass  # just ignore
        else:
            raise ValueError("Unknown button pressed in admin panel: '" +
                             str(button) + "'.")

    def exit_app_by_packet(self, packet):
        log.info("Exiting application trough remote command.")
        self.exit()

    def exit(self):
        self.is_running = False
        # if something fails, shooting_range is not yet created, thus we
        # trigger another exception when trying to set this variable. To
        # protect against this, let's check if the member variable exists
        # before accessing it
        if hasattr(
                self,
                'shooting_range') and self.shooting_range.target is not None:
            self.shooting_range.target.is_running = False

        self.backup_state()
        self.mi.close()
        self.mi = None

    def show_popup_from_packet(self, packet):
        if not 'title' in packet or not 'text' in packet:
            raise ValueError(
                "Invalid command: missing 'title' or 'text' field.")

        if 'buttons' in packet:
            buttons = packet['buttons']
        else:
            buttons = ['OK']

        self.widget_mgr.show_popup(packet['title'],
                                   packet['text'],
                                   buttons=buttons)

    def on_crossword_solved(self, _):
        self.widget_mgr.remove(self.puzzle)
        self.widget_mgr.show(self.door_panel)
        self.backup_state()

    def show_shooting_range(self):
        if self.shooting_range.target is not None:
            if self.shooting_range.state == ShootingRangeState.NOT_WORKING:
                raise Exception(
                    "Cannot start shooting range: Target is not working.")
            else:
                self.widget_mgr.show(self.shooting_range)

    def on_shooting_range_closed(self, _):
        self.widget_mgr.remove(self.shooting_range)

        # convert bonus point to time
        self.set_timeout(self.remaining_time_in_seconds() +
                         self.shooting_range.points_to_bonus_time())

        self.mi.send_packet({
            'event':
            'shooting_range_timeout',
            'bonus_time':
            self.shooting_range.points_to_bonus_time(),
            'total_points':
            self.shooting_range.total_points(),
            'remaining_time':
            self.remaining_time_in_seconds()
        })
        self.backup_state()

    def handle_exception_in_reddot_target(self, _):
        self.shooting_range.target.has_raised_exception.clear()
        exc, info = self.shooting_range.target.cached_exception
        raise exc from None

    def remaining_time_in_seconds(self):
        return max(math.ceil(self.time_ends - time.time()), 0)

    def remaining_time(self):
        return time_format(self.remaining_time_in_seconds())

    def shutdown(self, packet):
        log.info("Shutting down PC!!")
        subprocess.call(["sudo", "halt"])

    def show_help(self):
        self.widget_mgr.show_popup(
            'Hilfe',
            'Für jeden Verbrecher gibt es ein Rätsel. Löse die Rätsel und trage die Lösungsworte hier im Kreuzworträtsel ein um auszubrechen. '
            'Pfeiltasten auf der Tastatur benutzen zum navigieren. Sobald alles korrekt ausgefüllt ist erscheint die Türsteuerung. '
            'Bei Fragen oder wenn Ihr einen Tipp braucht einfach mit dem Telefon anrufen: Kurbeln und Höhrer ans Ohr halten.'
        )

    def reset(self):
        log.info("Resetting application!")
        self.screen.clear()

        self.puzzle.reset()
        self.door_panel.reset()
        self.shooting_range.reset()

        self.widget_mgr.remove_all()
        self.TIMEOUT = self.cfg["game_timeout"]
        self.set_timeout(self.TIMEOUT)

        self.widget_mgr.show(self.puzzle)

    def run(self):
        #ser.write(b'crossword running')
        self.is_running = True

        while self.is_running:
            self.widget_mgr.render()
            events = self.sel.select()

            for key, mask in events:
                callback = key.data
                callback(key.fileobj)

    def on_periodic_backup(self):
        self.backup_state()
        self.periodic_backup_timer.reset()
        self.periodic_backup_timer.start()

    def backup_state(self):
        state = {
            # Q: store this as an absolute timestamp, so time continues?
            # A: No, don't count time it took to restart app, that's not the players fault
            'time_remaining': self.remaining_time_in_seconds(),
            # TODO: puzzle state backup/restore should be handled in Crossword class itself
            'puzzle_input':
            [''.join(line) for line in self.puzzle.puzzle_input],
            'puzzle_solved': self.door_panel.visible
        }

        with open('state_backup.cfg', 'w') as state_file:
            json.dump(state, state_file)
            log.info("wrote state to backup file: {}".format(state))

    def clear_backup(self):
        if os.path.exists("state_backup.cfg"):
            log.info("deleting state backup")
            os.remove("state_backup.cfg")

    def load_backup(self):
        if not os.path.isfile('state_backup.cfg'):
            log.error("cannot restore state from backup: file does not exist")
            return None

        try:
            with open('state_backup.cfg', 'r') as state_file:
                return json.load(state_file)
        except:
            return None

    def restore_backup_by_packet(self, packet):
        if self.restore_backup():
            return self.mi.reply_success(packet)
        else:
            return self.mi.reply_failure(
                packet, "Could not restore state. Maybe there is no backup?")

    def restore_backup(self):
        state = self.load_backup()
        if state is None:
            return False

        # don't restore a completed game
        if state["time_remaining"] <= 0:
            return False

        self.set_timeout(state["time_remaining"])

        if state["puzzle_solved"]:
            self.widget_mgr.remove(self.puzzle)
            self.widget_mgr.show(self.door_panel)
            self.widget_mgr.render(clear=True)
        else:
            # TODO: puzzle state backup/restore should be handled in Crossword class itself
            self.puzzle.puzzle_input = [[c for c in line]
                                        for line in state["puzzle_input"]]
            self.puzzle.notify_state_update('restore')

        log.warning("Restored state from backup. Remaining time: {}".format(
            self.remaining_time_in_seconds()))
        self.mi.send_packet({
            'event': 'backup_restored',
            'remaining_time': self.remaining_time_in_seconds(),
        })
        return True

    def is_backup_different(self):
        """
        Check if there is anything in the backup to be interesting.
        """
        if not os.path.exists('state_backup.cfg'):
            return False  # no backup -> nothing interesting

        backup = self.load_backup()
        if not backup:
            log.error(
                "Failed to load backup even though file exists?! This should not happen."
            )
            return False

        if backup["time_remaining"] <= 0:
            return False

        if backup["puzzle_solved"]:
            return True

        # check crossword puzzle
        for line_backup, line_puzzle in zip(backup["puzzle_input"],
                                            self.puzzle.puzzle_input):
            if [c for c in line_backup] != line_puzzle:
                return True

        # nothing to restore from backup
        return False

    def check_for_backup(self):
        # check if backup contains anything interesting
        if self.is_backup_different():
            # if so, ask if you want to restore it
            self.widget_mgr.show_popup(
                'Wiederherstellen?',
                'Offenbar wurde das Spiel unterbrochen und nicht korrekt zu Ende gespielt.\n'
                'Dies sollte nicht passieren, bitte melden Sie diesen Vorfall der Spielleitung.\n\n'
                'Möchten Sie Ihren den vorherigen Zustand wieder rekonstruieren? Andernfalls müssen Sie mit dem Kreuzworträtsel von vorne beginnen.',
                callback=self._check_backup_popup_cb,
                buttons=['WIEDERHERSTELLEN', 'NEUES SPIEL'])

    def _check_backup_popup_cb(self, button):
        if button == 'WIEDERHERSTELLEN':
            self.restore_backup()

    def new_connection_handler(self, connection):
        # notify newly connected clients about the current state of things
        # (these will notify *all* clients, but that shouldn't be a problem)
        self.widget_mgr.send_stack_update(force=True)
        self.puzzle.notify_state_update("new_connection")

    def get_screen_width(self):
        H, W = self.screen.getmaxyx()
        return W

    # from https://stackoverflow.com/a/9567831
    def memory_dump(self):
        log.info("collecting garbage...")
        gc.collect()
        log.info("dumping memory to 'memory_dump.pickle'...")
        xs = []
        for obj in gc.get_objects():
            i = id(obj)
            size = sys.getsizeof(obj, 0)
            #    referrers = [id(o) for o in gc.get_referrers(obj) if hasattr(o, '__class__')]
            referents = [
                id(o) for o in gc.get_referents(obj)
                if hasattr(o, '__class__')
            ]

            cls = None
            if hasattr(obj, '__class__'):
                cls = str(obj.__class__)
            xs.append({
                'id': i,
                'class': cls,
                'str': str(obj),
                'size': size,
                'referents': referents
            })

        with open('memory_dump.pickle', 'wb') as dump:
            pickle.dump(xs, dump, pickle.HIGHEST_PROTOCOL)
        log.info("memory dump complete")

    def wakeup_screen(self):
        log.info("sending key to wakeup screen")
        subprocess.check_call(["xdotool", "key", "Up"])