def __setitem__(self, action, key_list): assert action in self._actions if isinstance(key_list, str): key_list = (key_list, ) # Delete previous bindings. if action in self._mappings: for old_key in self._mappings[action]: if old_key in self._bindings: del self._bindings[old_key] errors = [] valid_key_list = [] for key in key_list: if key not in self._keys: errors.append('invalid key %s bound to action %s' % (key, action)) continue if key in self._bindings: errors.append('key %s is already bound to: %s' % (key, self._bindings[key])) continue valid_key_list.append(key) self._bindings[key] = action self._mappings[action] = tuple( sorted(valid_key_list, key=self._keys.get)) if len(errors) > 0: log.warning('Keymap is invalid, behavior undefined:\n\n- ' + '\n- '.join(errors))
def start_capture(self): """Begin listening for output from the stenotype machine.""" if not self._connect(): log.warning('Treal is not connected') self._error() return super(Treal, self).start_capture()
def find_stenograph(self): try: log.warning("Searching for Wi-Fi Stenographs...") udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP) udp.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) udp.settimeout(10) client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) while self._stenograph_address == None: udp.sendto(BATTLE_CRY, (BROADCAST_ADDRESS, BROADCAST_PORT)) sleep(1.2) data, address = udp.recvfrom(65565) if "Mira in the neighborhood" in data.decode("utf-8"): self._stenograph_address = address udp.close() break except client.timeout as e: log.warning('Client timed out: %s' % e) return self._stenograph_address
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 start_capture(self): self.finished.clear() self._initializing() """Begin listening for output from the stenotype machine.""" if not self._connect_machine(): log.warning('Writer not found. Try clicking refresh.') self._error() else: self._ready() self.start()
def start_capture(self): self.finished.clear() self._initializing() """Begin listening for output from the stenotype machine.""" if not self._connect_machine(): log.warning('Stenograph machine is not connected') self._error() else: self._ready() self.start()
def start_capture(self): """Begin listening for output from the stenotype machine.""" try: self._machine = hid.device(VENDOR_ID, 1) self._machine.set_nonblocking(1) except IOError as e: log.info('Treal device not found: %s', str(e)) log.warning('Treal is not connected') self._error() return return ThreadedStenotypeBase.start_capture(self)
def _connect_machine(self): connected = False try: connected = self._machine.connect() except AssertionError as e: log.warning('Error connecting: %s', e) self._error() except IOError as e: log.warning('Lost connection with Stenograph machine: %s', e) self._error() finally: return connected
def _connect_machine(self): connected = False try: connected = self._machine.connect() except ValueError: log.warning('Libusb must be installed.') self._error() except AssertionError as e: log.warning('Error connecting: %s', e) self._error() finally: return connected
def add_dictionary(self, event): dlg = wx.FileDialog(self, "Choose a file", os.getcwd(), "", self.mask, wx.MULTIPLE) if dlg.ShowModal() == wx.ID_OK: paths = dlg.GetPaths() all_dicts = [x.label.GetLabel() for x in self.dictionary_controls] for path in paths: if not os.path.isfile(path): log.warning('"%s" is not a file.', path) elif path in all_dicts: log.warning('Dictionary already added, "%s"', path) else: self.add_row(path) dlg.Destroy()
def set_log_file_name(self, config): """Set the file name for log output.""" filename = config.get_log_file_name() if not filename: return if os.path.realpath(filename) == os.path.realpath(log.LOG_FILENAME): log.warning('stroke logging must use a different file than %s, ' 'renaming to %s', log.LOG_FILENAME, conf.DEFAULT_LOG_FILE) filename = conf.DEFAULT_LOG_FILE config.set_log_file_name(filename) with open(config.target_file, 'wb') as f: config.save(f) log.set_stroke_filename(filename)
def _update_image_resource(self, url, data): if url not in self._images: # Ignore request from a previous document. return image = QImage.fromData(data) if image is None: log.warning('could not load image from %s', url) return doc = self.document() doc.addResource(QTextDocument.ImageResource, QUrl(url), image) for frag in self._iter_fragments(): fmt = frag.charFormat() if fmt.isImageFormat() and fmt.toImageFormat().name() == url: doc.markContentsDirty(frag.position(), frag.length())
def run(self): handler = DataHandler(self._on_stroke) self._ready() while not self.finished.isSet(): try: packet = self._machine.read(5, 100) except IOError: self._machine.close() log.warning(u'Treal disconnected, reconnecting…') if self._reconnect(): log.warning('Treal reconnected.') else: if len(packet) is 5: handler.update(packet)
def set_log_file_name(self, config): """Set the file name for log output.""" filename = config.get_log_file_name() if not filename: return if os.path.realpath(filename) == os.path.realpath(log.LOG_FILENAME): log.warning( 'stroke logging must use a different file than %s, ' 'renaming to %s', log.LOG_FILENAME, conf.DEFAULT_LOG_FILE) filename = conf.DEFAULT_LOG_FILE config.set_log_file_name(filename) with open(config.target_file, 'wb') as f: config.save(f) log.set_stroke_filename(filename)
def update_engine(engine, config, reset_machine=False): """Modify a StenoEngine using a before and after config object. Using the before and after allows this function to not make unnecessary changes. """ if reset_machine: engine.set_machine(None) machine_type = config.get_machine_type() try: machine_class = machine_registry.get(machine_type) except NoSuchMachineException as e: raise InvalidConfigurationError(unicode(e)) machine_options = config.get_machine_specific_options(machine_type) machine_mappings = config.get_system_keymap(machine_type) engine.set_machine(machine_class, machine_options, machine_mappings) dictionary_file_names = config.get_dictionary_file_names() engine.set_dictionaries(dictionary_file_names) log_file_name = config.get_log_file_name() if log_file_name: # Older versions would use "plover.log" for logging strokes. if os.path.realpath(log_file_name) == os.path.realpath(log.LOG_FILENAME): log.warning('stroke logging must use a different file than %s, ' 'renaming to %s', log.LOG_FILENAME, conf.DEFAULT_LOG_FILE) log_file_name = conf.DEFAULT_LOG_FILE config.set_log_file_name(log_file_name) with open(config.target_file, 'wb') as f: config.save(f) engine.set_log_file_name(log_file_name) enable_stroke_logging = config.get_enable_stroke_logging() engine.enable_stroke_logging(enable_stroke_logging) enable_translation_logging = config.get_enable_translation_logging() engine.enable_translation_logging(enable_translation_logging) space_placement = config.get_space_placement() engine.set_space_placement(space_placement) undo_levels = config.get_undo_levels() engine.set_undo_levels(undo_levels) start_capitalized = config.get_start_capitalized() start_attached = config.get_start_attached() engine.set_starting_stroke_state(attach=start_attached, capitalize=start_capitalized)
def start_capture(self): """Begin listening for output from the stenotype machine.""" try: if hasattr(hid.device, 'open'): self._machine = hid.device() self._machine.open(VENDOR_ID, 1) else: self._machine = hid.device(VENDOR_ID, 1) self._machine.set_nonblocking(0) except IOError as e: log.info('Treal device not found: %s', str(e)) log.warning('Treal is not connected') self._error() return super(Stenotype, self).start_capture()
def set_mappings(self, mappings): # When setting from a string, assume a list of mappings: # [[action1, [key1, key2]], [action2, [key3]], ...] if isinstance(mappings, str): mappings = json.loads(mappings) mappings = dict(mappings) # Set from: # { action1: [key1, key2], ... actionn: [keyn] } self._mappings = OrderedDict() self._bindings = {} bound_keys = defaultdict(list) errors = [] for action in self._actions: key_list = mappings.get(action) if not key_list: # Not an issue if 'no-op' is not mapped... if action != 'no-op': errors.append('action %s is not bound' % action) # Add dummy mapping for each missing action # so it's shown in the configurator. self._mappings[action] = () continue if isinstance(key_list, str): key_list = (key_list, ) valid_key_list = [] for key in key_list: if key not in self._keys: errors.append('invalid key %s bound to action %s' % (key, action)) continue valid_key_list.append(key) bound_keys[key].append(action) self._bindings[key] = action self._mappings[action] = tuple( sorted(valid_key_list, key=self._keys.get)) for action in (set(mappings) - set(self._actions)): key_list = mappings.get(action) if isinstance(key_list, str): key_list = (key_list, ) errors.append('invalid action %s mapped to key(s) %s' % (action, ' '.join(key_list))) for key, action_list in bound_keys.items(): if len(action_list) > 1: errors.append('key %s is bound multiple times: %s' % (key, str(action_list))) if len(errors) > 0: log.warning('Keymap is invalid, behavior undefined:\n\n- ' + '\n- '.join(errors))
def start_capture(self): self._close_port() try: self.serial_port = serial.Serial(**self.serial_params) except (serial.SerialException, OSError): log.warning('Can\'t open serial port', exc_info=True) self._error() return if not self.serial_port.isOpen(): log.warning('Serial port is not open: %s', self.serial_params.get('port')) self._error() return return ThreadedStenotypeBase.start_capture(self)
def start_capture(self): self._close_port() try: self.serial_port = serial.Serial(**self.serial_params) except (serial.SerialException, OSError) as e: log.warning('Can\'t open Serial port: %s', str(e)) self._error() return if not self.serial_port.isOpen(): log.warning('Serial port is not open: %s', self.serial_params.get('port')) self._error() return return ThreadedStenotypeBase.start_capture(self)
def update_engine(engine, config, reset_machine=False): """Modify a StenoEngine using a before and after config object. Using the before and after allows this function to not make unnecessary changes. """ machine_type = config.get_machine_type() try: machine_class = machine_registry.get(machine_type) except NoSuchMachineException as e: raise InvalidConfigurationError(str(e)) machine_options = config.get_machine_specific_options(machine_type) machine_mappings = config.get_system_keymap(machine_type) engine.set_machine(machine_class, machine_options, machine_mappings, reset_machine=reset_machine) dictionary_file_names = config.get_dictionary_file_names() engine.set_dictionaries(dictionary_file_names) log_file_name = config.get_log_file_name() if log_file_name: # Older versions would use "plover.log" for logging strokes. if os.path.realpath(log_file_name) == os.path.realpath(log.LOG_FILENAME): log.warning('stroke logging must use a different file than %s, ' 'renaming to %s', log.LOG_FILENAME, conf.DEFAULT_LOG_FILE) log_file_name = conf.DEFAULT_LOG_FILE config.set_log_file_name(log_file_name) with open(config.target_file, 'wb') as f: config.save(f) engine.set_log_file_name(log_file_name) enable_stroke_logging = config.get_enable_stroke_logging() engine.enable_stroke_logging(enable_stroke_logging) enable_translation_logging = config.get_enable_translation_logging() engine.enable_translation_logging(enable_translation_logging) space_placement = config.get_space_placement() engine.set_space_placement(space_placement) undo_levels = config.get_undo_levels() engine.set_undo_levels(undo_levels) start_capitalized = config.get_start_capitalized() start_attached = config.get_start_attached() engine.set_starting_stroke_state(attach=start_attached, capitalize=start_capitalized)
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 start_capture(self): """Begin listening for output from the stenotype machine.""" devices = hid.HidDeviceFilter(vendor_id=VENDOR_ID).get_devices() if len(devices) == 0: log.info('Treal: no devices with vendor id %s', str(VENDOR_ID)) log.warning('Treal not connected') self._error() return self._machine = devices[0] self._machine.open() handler = DataHandler(self._notify) def callback(p): if len(p) != 6: return handler.update(p[1:]) self._machine.set_raw_data_handler(callback) self._ready()
def _update_registry(): # From MSDN documentation: # # The hook procedure should process a message in less time than the # data entry specified in the LowLevelHooksTimeout value in the # following registry key: # # HKEY_CURRENT_USER\Control Panel\Desktop # # The value is in milliseconds. If the hook procedure times out, the # system passes the message to the next hook. However, on Windows 7 and # later, the hook is silently removed without being called. There is no # way for the application to know whether the hook is removed. def _open_key(rights): return winreg.OpenKey(winreg.HKEY_CURRENT_USER, r'Control Panel\Desktop', 0, rights) REG_LLHOOK_KEY_FULL_NAME = r'HKEY_CURRENT_USER\Control Panel\Desktop\LowLevelHooksTimeout' REG_LLHOOK_KEY_VALUE_NAME = 'LowLevelHooksTimeout' REG_LLHOOK_KEY_VALUE_TYPE = winreg.REG_DWORD REG_LLHOOK_KEY_VALUE = 5000 read_key = _open_key(winreg.KEY_READ) try: value, value_type = winreg.QueryValueEx(read_key, REG_LLHOOK_KEY_VALUE_NAME) except WindowsError: value, value_type = (None, None) if value_type != REG_LLHOOK_KEY_VALUE_TYPE or value != REG_LLHOOK_KEY_VALUE: try: write_key = _open_key(winreg.KEY_WRITE) winreg.SetValueEx(write_key, REG_LLHOOK_KEY_VALUE_NAME, 0, REG_LLHOOK_KEY_VALUE_TYPE, REG_LLHOOK_KEY_VALUE) except WindowsError: log.warning( 'could not update registry key: %s, see documentation', REG_LLHOOK_KEY_FULL_NAME) else: log.warning( 'the following registry key has been updated, ' 'you should reboot: %s', REG_LLHOOK_KEY_FULL_NAME)
def __init__(self, assignments): assignments = dict(assignments) self.keymap = OrderedDict() bound_keys = {} # Keep only valid entries, and add missing entries. for action, _ in Keymap.DEFAULT: keylist = assignments.get(action, ()) for key in keylist: if key in bound_keys: bound_keys[key].append(action) else: bound_keys[key] = [action] self.keymap[action] = keylist errors = [] for key, action_list in bound_keys.items(): if len(action_list) > 1: errors.append('key %s is bound multiple times: %s' % (key, str(action_list))) if len(errors) > 0: log.warning('Keymap is invalid, behavior undefined:\n\n- ' + '\n- '.join(errors))
def set_mappings(self, mappings): # When setting from a string, assume a list of mappings: # [[action1, [key1, key2]], [action2, [key3]], ...] if isinstance(mappings, str): mappings = json.loads(mappings) mappings = dict(mappings) # Set from: # { action1: [key1, key2], ... actionn: [keyn] } self._mappings = OrderedDict() self._bindings = {} bound_keys = defaultdict(list) errors = [] for action in self._actions: key_list = mappings.get(action) if not key_list: # Not an issue if 'no-op' is not mapped... if action != 'no-op': errors.append('action %s is not bound' % action) # Add dummy mapping for each missing action # so it's shown in the configurator. self._mappings[action] = () continue if isinstance(key_list, str): key_list = (key_list,) valid_key_list = [] for key in key_list: if key not in self._keys: errors.append('invalid key %s bound to action %s' % (key, action)) continue valid_key_list.append(key) bound_keys[key].append(action) self._bindings[key] = action self._mappings[action] = tuple(sorted(valid_key_list, key=self._keys.get)) for action in (set(mappings) - set(self._actions)): key_list = mappings.get(action) if isinstance(key_list, str): key_list = (key_list,) errors.append('invalid action %s mapped to key(s) %s' % (action, ' '.join(key_list))) for key, action_list in bound_keys.items(): if len(action_list) > 1: errors.append('key %s is bound multiple times: %s' % (key, str(action_list))) if len(errors) > 0: log.warning('Keymap is invalid, behavior undefined:\n\n- ' + '\n- '.join(errors))
def _update_registry(): # From MSDN documentation: # # The hook procedure should process a message in less time than the # data entry specified in the LowLevelHooksTimeout value in the # following registry key: # # HKEY_CURRENT_USER\Control Panel\Desktop # # The value is in milliseconds. If the hook procedure times out, the # system passes the message to the next hook. However, on Windows 7 and # later, the hook is silently removed without being called. There is no # way for the application to know whether the hook is removed. def _open_key(rights): return winreg.OpenKey(winreg.HKEY_CURRENT_USER, r'Control Panel\Desktop', 0, rights) REG_LLHOOK_KEY_FULL_NAME = r'HKEY_CURRENT_USER\Control Panel\Desktop\LowLevelHooksTimeout' REG_LLHOOK_KEY_VALUE_NAME = 'LowLevelHooksTimeout' REG_LLHOOK_KEY_VALUE_TYPE = winreg.REG_DWORD REG_LLHOOK_KEY_VALUE = 5000 read_key = _open_key(winreg.KEY_READ) try: value, value_type = winreg.QueryValueEx(read_key, REG_LLHOOK_KEY_VALUE_NAME) except WindowsError: value, value_type = (None, None) if value_type != REG_LLHOOK_KEY_VALUE_TYPE or value != REG_LLHOOK_KEY_VALUE: try: write_key = _open_key(winreg.KEY_WRITE) winreg.SetValueEx(write_key, REG_LLHOOK_KEY_VALUE_NAME, 0, REG_LLHOOK_KEY_VALUE_TYPE, REG_LLHOOK_KEY_VALUE) except WindowsError as e: log.warning('could not update registry key: %s, see documentation', REG_LLHOOK_KEY_FULL_NAME) else: log.warning('the following registry key has been updated, ' 'you should reboot: %s', REG_LLHOOK_KEY_FULL_NAME)
def __setitem__(self, action, key_list): assert action in self._actions if isinstance(key_list, string_types): key_list = (key_list,) # Delete previous bindings. if action in self._mappings: for old_key in self._mappings[action]: if old_key in self._bindings: del self._bindings[old_key] errors = [] for key in key_list: if key not in self._keys: errors.append('invalid key %s bound to action %s' % (key, action)) if key in self._bindings: action_list = (action, self._bindings[key]) errors.append('key %s is bound multiple times: %s' % (key, str(action_list))) del self._bindings[key] self._bindings[key] = action if len(errors) > 0: log.warning('Keymap is invalid, behavior undefined:\n\n- ' + '\n- '.join(errors))
def connect(self): """Attempt to connect and return connection""" # Disconnect device if it's already connected. if self._connected: self.disconnect() # Find IP of Stenograph machine. self._stenograph_address = self.find_stenograph() # No IP address = no device found. if not self._stenograph_address: return self._connected # Now create a TCP connection to the found machine's IP address. try: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.settimeout(10) sock.connect((self._stenograph_address[0], 80)) self._sock = sock log.warning('Stenograph writer found at IP address: %s!' % self._stenograph_address[0]) except socket.timeout as e: log.warning('Stenograph writer timed out: %s' % e) except socket.error as exc: log.warning('Stenograph writer binding error: %s' % exc) self._connected = True return self._connected
def list_plugins(): working_set = WorkingSet() # Make sure user site packages are added # to the set so user plugins are listed. user_site_packages = site.USER_SITE if not running_under_virtualenv() and \ user_site_packages not in working_set.entries: working_set.entry_keys.setdefault(user_site_packages, []) working_set.entries.append(user_site_packages) for dist in find_distributions(user_site_packages, only=True): working_set.add(dist, user_site_packages, replace=True) plugins = defaultdict(list) for dist in working_set.by_key.values(): if dist.key == 'plover': continue for entrypoint_type in dist.get_entry_map().keys(): if entrypoint_type.startswith('plover.'): break else: continue if isinstance(dist, DistInfoDistribution): metadata_entry = 'METADATA' else: # Assume it's an egg distribution... metadata_entry = 'PKG-INFO' if not dist.has_metadata(metadata_entry): log.warning('ignoring distribution (missing metadata): %s', dist) continue metadata = Metadata() metadata.parse(dist.get_metadata(metadata_entry)) plugin_metadata = PluginMetadata.from_dict({ attr: getattr(metadata, attr) for attr in PluginMetadata._fields }) plugins[dist.key].append(plugin_metadata) return { name: list(sorted(versions)) for name, versions in plugins.items() }
def connect(self): """Attempt to and return connection""" # Disconnect device if it's already connected. if self._connected: self.disconnect() # Find the device by the vendor ID. usb_device = core.find(idVendor=VENDOR_ID) if not usb_device: # Device not found return self._connected # Copy the default configuration. try: usb_device.set_configuration() except core.USBError as e: log.warning('Error connecting: %s', e) self._error() config = usb_device.get_active_configuration() interface = config[(0, 0)] # Get the write endpoint. endpoint_out = util.find_descriptor( interface, custom_match=lambda e: util.endpoint_direction( e.bEndpointAddress) == util.ENDPOINT_OUT) assert endpoint_out is not None, 'cannot find write endpoint' # Get the read endpoint. endpoint_in = util.find_descriptor( interface, custom_match=lambda e: util.endpoint_direction( e.bEndpointAddress) == util.ENDPOINT_IN) assert endpoint_in is not None, 'cannot find read endpoint' self._usb_device = usb_device self._endpoint_in = endpoint_in self._endpoint_out = endpoint_out self._connected = True return self._connected
def _connect(self): connected = False # Set plover mode to initializing self._initializing() try: # Init the raw pins io.setup(self._modeSelectPin, io.IN, pull_up_down = io.PUD_UP) io.setup(16, io.IN, pull_up_down = io.PUD_UP) io.setup(20, io.IN, pull_up_down = io.PUD_UP) io.setup(21, io.IN, pull_up_down = io.PUD_UP) io.setup(1, io.IN, pull_up_down = io.PUD_UP) io.setup(26, io.IN, pull_up_down = io.PUD_UP) io.setup(19, io.IN, pull_up_down = io.PUD_UP) io.setup(13, io.IN, pull_up_down = io.PUD_UP) io.setup(6, io.IN, pull_up_down = io.PUD_UP) io.setup(0, io.IN, pull_up_down = io.PUD_UP) # Init the port expander pins self._bus = smbus.SMBus(1) self._bus.write_byte_data(0x20, 0x0c, 0xff) self._bus.write_byte_data(0x20, 0x0d, 0xff) # Check if switch on board is set to NKRO if io.input(self._modeSelectPin): log.warning("NKRO not selected on board. TinyMod4 plugin Disabled.") self._error() return connected self._ready() connected = True return connected except: log.warning("Error setting up TinyMod4") self._error() return connected
def __setitem__(self, action, key_list): assert action in self._actions if isinstance(key_list, str): key_list = (key_list,) # Delete previous bindings. if action in self._mappings: for old_key in self._mappings[action]: if old_key in self._bindings: del self._bindings[old_key] errors = [] valid_key_list = [] for key in key_list: if key not in self._keys: errors.append('invalid key %s bound to action %s' % (key, action)) continue if key in self._bindings: errors.append('key %s is already bound to: %s' % (key, self._bindings[key])) continue valid_key_list.append(key) self._bindings[key] = action self._mappings[action] = tuple(sorted(valid_key_list, key=self._keys.get)) if len(errors) > 0: log.warning('Keymap is invalid, behavior undefined:\n\n- ' + '\n- '.join(errors))
def __setitem__(self, action, key_list): assert action in self._actions if isinstance(key_list, string_types): key_list = (key_list, ) # Delete previous bindings. if action in self._mappings: for old_key in self._mappings[action]: if old_key in self._bindings: del self._bindings[old_key] errors = [] for key in key_list: if key not in self._keys: errors.append('invalid key %s bound to action %s' % (key, action)) if key in self._bindings: action_list = (action, self._bindings[key]) errors.append('key %s is bound multiple times: %s' % (key, str(action_list))) del self._bindings[key] self._bindings[key] = action if len(errors) > 0: log.warning('Keymap is invalid, behavior undefined:\n\n- ' + '\n- '.join(errors))
def start_capture(self): if self.serial_port: self.serial_port.close() try: self.serial_port = serial.Serial(**self.serial_params) except (serial.SerialException, OSError) as e: log.warning('Stentura not connected') log.info('Can\'t open Serial port: %s', str(e)) self._error() return if self.serial_port is None: log.warning('Serial port not found: %s', str(e)) self._error() return if not self.serial_port.isOpen(): log.warning('Serial port is not open: %s', str(e)) self._error() return return ThreadedStenotypeBase.start_capture(self)
def start_capture(self): if self.serial_port: self.serial_port.close() try: self.serial_port = serial.Serial(**self.serial_params) except (serial.SerialException, OSError) as e: log.warning('Machine not connected') log.info('Can\'t open Serial port: %s', str(e)) self._error() return if self.serial_port is None: log.warning('Serial port not found: %s', str(e)) self._error() return if not self.serial_port.isOpen(): log.warning('Serial port is not open: %s', str(e)) self._error() return return ThreadedStenotypeBase.start_capture(self)
import sys from plover import log handler = None try: if sys.platform.startswith('linux'): from plover.oslayer.log_dbus import DbusNotificationHandler handler_class = DbusNotificationHandler elif sys.platform.startswith('darwin'): from plover.oslayer.log_osx import OSXNotificationHandler handler_class = OSXNotificationHandler except Exception: log.warning('could not import platform gui log', exc_info=True) else: try: handler = handler_class() except Exception: log.error('could not initialize platform gui log', exc_info=True) if handler is None: from plover.gui.log_wx import WxNotificationHandler handler = WxNotificationHandler() log.add_handler(handler)