def run(self):
     self._reset_state()
     while not self.finished.isSet():
         try:
             response = self._machine.read(self._file_offset)
         except IOError as e:
             log.warning(u'Stenograph machine disconnected, reconnecting…')
             log.debug('Stenograph exception: %s', str(e))
             self._reset_state()
             if self._reconnect():
                 log.warning('Stenograph reconnected.')
                 self._ready()
         except EOFError:
             # File ended -- will resume normal operation after new file
             self._reset_state()
         else:
             if response is None:
                 continue
             if not self._read_exactly_8 and len(response) == 8:
                 self._read_exactly_8 = True
             content = len(response) > 0
             self._file_offset += len(response)
             if not self._realtime and not content:
                 self._realtime = True
             elif self._realtime and content and self._read_exactly_8:
                 chords = Stenograph.process_steno_packet(response)
                 for keys in chords:
                     if keys:
                         self._on_stroke(keys)
     self._machine.disconnect()
Exemplo n.º 2
0
 def _send_receive(self, request):
     """Send a StenoPacket and return the response or raise exceptions."""
     log.debug('Requesting from Stenograph: %s', request)
     response = self._machine.send_receive(request)
     log.debug('Response from Stenograph: %s', response)
     if response is None:
         """No response implies device connection issue."""
         raise IOError()
     elif response.packet_id == StenoPacket.ID_ERROR:
         """Writer may reply with an error packet"""
         error_number = response.p1
         if error_number == 3:
             raise UnableToPerformRequestException()
         elif error_number == 7:
             raise FileNotAvailableException()
         elif error_number == 8:
             raise NoRealtimeFileException()
         elif error_number == 9:
             raise FinishedReadingClosedFileException()
     else:
         """Writer has returned a packet"""
         if (response.packet_id != request.packet_id
                 or response.sequence_number != request.sequence_number):
             raise ProtocolViolationException()
         return response
Exemplo n.º 3
0
 def start_loading(self, filename):
     op = self.dictionaries.get(filename)
     if op is not None:
         return self.dictionaries[filename]
     log.debug("loading dictionary: %s", filename)
     op = DictionaryLoadingOperation(filename)
     self.dictionaries[filename] = op
     return op
Exemplo n.º 4
0
 def start_loading(self, filename):
     op = self.dictionaries.get(filename)
     if op is not None:
         return self.dictionaries[filename]
     log.debug('loading dictionary: %s', filename)
     op = DictionaryLoadingOperation(filename)
     self.dictionaries[filename] = op
     return op
Exemplo n.º 5
0
        def _open_device_by_class_interface_and_instance(class_guid):
            device_info = SetupDiGetClassDevs(class_guid.bytes, 0, 0, 0x12)
            if device_info == INVALID_HANDLE_VALUE:
                log.debug('dev info is invalid handle')
                return INVALID_HANDLE_VALUE

            usb_device = StenographMachine._open_device_instance(
                device_info, class_guid)
            return usb_device
Exemplo n.º 6
0
 def load(self):
     timestamp = None
     try:
         timestamp = resource_timestamp(self.filename)
         self.result = load_dictionary(self.filename)
     except Exception as e:
         log.debug('loading dictionary %s failed', self.filename, exc_info=True)
         self.result = DictionaryLoaderException(self.filename, e)
         self.result.timestamp = timestamp
Exemplo n.º 7
0
 def load(self):
     timestamp = None
     try:
         timestamp = resource_timestamp(self.filename)
         self.result = load_dictionary(self.filename)
     except Exception as e:
         log.debug('loading dictionary %s failed', self.filename, exc_info=True)
         self.result = DictionaryLoaderException(self.filename, e)
         self.result.timestamp = timestamp
Exemplo n.º 8
0
 def set_is_running(self, value):
     if value != self.is_running:
         log.debug('%s output', 'enabling' if value else 'disabling')
     self.is_running = value
     if self.is_running:
         self.translator.set_state(self.running_state)
         self.formatter.set_output(self.full_output)
     else:
         self.translator.clear_state()
         self.formatter.set_output(self.command_only_output)
     if self.machine is not None:
         self.machine.set_suppression(self.is_running)
     for callback in self.subscribers:
         callback(None)
Exemplo n.º 9
0
 def set_is_running(self, value):
     if value != self.is_running:
         log.debug('%s output', 'enabling' if value else 'disabling')
     self.is_running = value
     if self.is_running:
         self.translator.set_state(self.running_state)
         self.formatter.set_output(self.full_output)
     else:
         self.translator.clear_state()
         self.formatter.set_output(self.command_only_output)
     if self.machine is not None:
         self.machine.set_suppression(self.is_running)
     for callback in self.subscribers:
         callback(None)
Exemplo n.º 10
0
    def run(self):
        class ReadState(object):
            def __init__(self):
                self.realtime = False  # Not realtime until we get a 0-length response
                self.realtime_file_open = False  # We are reading from a file
                self.offset = 0  # File offset to read from

            def reset(self):
                self.__init__()

        state = ReadState()

        while not self.finished.isSet():
            try:
                if not state.realtime_file_open:
                    # Open realtime file
                    self._send_receive(StenoPacket.make_open_request())
                    state.realtime_file_open = True
                response = self._send_receive(
                    StenoPacket.make_read_request(file_offset=state.offset))
            except IOError as e:
                log.warning(u'Stenograph writer disconnected, reconnecting…')
                log.debug('Stenograph exception: %s', e)

                # User could start a new file while disconnected.
                state.reset()
                if self._reconnect():
                    log.warning('Stenograph writer reconnected.')
                    self._ready()
            except NoRealtimeFileException:
                # User hasn't started writing, just keep opening the realtime file
                state.reset()
            except FinishedReadingClosedFileException:
                # File closed! Open the realtime file.
                state.reset()
            else:
                if response.data_length:
                    state.offset += response.data_length
                elif not state.realtime:
                    state.realtime = True
                if response.data_length and state.realtime:
                    for stroke in response.strokes():
                        self._on_stroke(stroke)

        self._machine.disconnect()
Exemplo n.º 11
0
    def run(self):
        settings = self.serial_port.getSettingsDict()
        settings['timeout'] = 0.01
        self.serial_port.applySettingsDict(settings)
        for command in REALTIME_COMMANDS:
            log.debug('Palantype: sending %s', str(command))
            self.serial_port.write(bytearray(command))
            sleep(0.5)
        self._ready()
        while not self.finished.isSet():
            if not self.serial_port.inWaiting():
                self.serial_port.write(REQUEST_READ)
                # Request a read 5 times a second
                sleep(0.2)

            raw = self.serial_port.read(5)
            if raw is None:
                continue
            log.debug('Palantype: read %s', raw)
            try:
                # Look for start of chord
                stroke_beginning = raw.index(1)
            except ValueError:
                pass
            else:
                # Trim anything else
                raw = raw[stroke_beginning:]
                if len(raw) < 5:
                    # Read more if it's an incomplete chord
                    raw += self.serial_port.read(5 - len(raw))
                if len(raw) == 5:
                    keys = self._parse_packet(raw)
                    steno_keys = self.keymap.keys_to_actions(keys)
                    if steno_keys:
                        self._notify(steno_keys)

        if self.serial_port:
            self.serial_port.write(END)
Exemplo n.º 12
0
 def set_machine(self, machine_class,
                 machine_options=None,
                 machine_mappings=None,
                 reset_machine=False):
     if (not reset_machine and
         self.machine_class == machine_class and
         self.machine_options == machine_options and
         self.machine_mappings == machine_mappings):
         return
     if self.machine is not None:
         log.debug('stopping machine: %s', self.machine_class.__name__)
         self.machine.remove_state_callback(self._machine_state_callback)
         self.machine.remove_stroke_callback(
             self._translator_machine_callback)
         self.machine.remove_stroke_callback(log.stroke)
         self.machine.stop_capture()
         self.machine_class = None
         self.machine_options = None
         self.machine_mappings = None
         self.machine = None
     if machine_class is not None:
         log.debug('starting machine: %s', machine_class.__name__)
         machine = machine_class(machine_options)
         if machine_mappings is not None:
            machine.set_mappings(machine_mappings)
         machine.add_state_callback(self._machine_state_callback)
         machine.add_stroke_callback(log.stroke)
         machine.add_stroke_callback(self._translator_machine_callback)
         self.machine = machine
         self.machine_class = machine_class
         self.machine_options = machine_options
         self.machine_mappings = machine_mappings
         self.machine.start_capture()
         is_running = self.is_running
     else:
         is_running = False
     self.set_is_running(is_running)
Exemplo n.º 13
0
 def set_machine(self, machine_class,
                 machine_options=None,
                 machine_mappings=None,
                 reset_machine=False):
     if (not reset_machine and
         self.machine_class == machine_class and
         self.machine_options == machine_options and
         self.machine_mappings == machine_mappings):
         return
     if self.machine is not None:
         log.debug('stopping machine: %s', self.machine_class.__name__)
         self.machine.remove_state_callback(self._machine_state_callback)
         self.machine.remove_stroke_callback(
             self._translator_machine_callback)
         self.machine.remove_stroke_callback(log.stroke)
         self.machine.stop_capture()
         self.machine_class = None
         self.machine_options = None
         self.machine_mappings = None
         self.machine = None
     if machine_class is not None:
         log.debug('starting machine: %s', machine_class.__name__)
         machine = machine_class(machine_options)
         if machine_mappings is not None:
            machine.set_mappings(machine_mappings)
         machine.add_state_callback(self._machine_state_callback)
         machine.add_stroke_callback(log.stroke)
         machine.add_stroke_callback(self._translator_machine_callback)
         self.machine = machine
         self.machine_class = machine_class
         self.machine_options = machine_options
         self.machine_mappings = machine_mappings
         self.machine.start_capture()
         is_running = self.is_running
     else:
         is_running = False
     self.set_is_running(is_running)
Exemplo n.º 14
0
        def _open_device_instance(device_info, guid):
            dev_interface_data = DeviceInterfaceData()
            dev_interface_data.cbSize = sizeof(dev_interface_data)

            status = SetupDiEnumDeviceInterfaces(device_info, None, guid.bytes,
                                                 0, byref(dev_interface_data))
            if status == 0:
                log.debug('status is zero')
                return INVALID_HANDLE_VALUE

            request_length = DWORD(0)
            # Call with None to see how big a buffer we need for detail data.
            SetupDiGetInterfaceDeviceDetail(device_info,
                                            byref(dev_interface_data), None, 0,
                                            pointer(request_length), None)
            err = GetLastError()
            if err != ERROR_INSUFFICIENT_BUFFER:
                log.debug('last error not insufficient buffer')
                return INVALID_HANDLE_VALUE

            characters = request_length.value

            class DeviceDetailData(Structure):
                _fields_ = [('cbSize', DWORD),
                            ('DevicePath', c_char * characters)]

            dev_detail_data = DeviceDetailData()
            dev_detail_data.cbSize = 5

            # Now put the actual detail data into the buffer
            status = SetupDiGetInterfaceDeviceDetail(device_info,
                                                     byref(dev_interface_data),
                                                     byref(dev_detail_data),
                                                     characters,
                                                     pointer(request_length),
                                                     None)
            if not status:
                log.debug('not status')
                return INVALID_HANDLE_VALUE
            log.debug('okay, creating file')
            return CreateFile(dev_detail_data.DevicePath, 0xC0000000, 0x3, 0,
                              0x3, 0x80, 0)