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()
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
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
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
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
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
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
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)
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)
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()
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)
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)
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)
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)