def make_observer(self, monitor, use_deprecated=False):
if use_deprecated:
if pytest.__version__ == "2.8.4":
self.observer = MonitorObserver(
monitor, event_handler=self.event_handler)
else:
self.observer = pytest.deprecated_call(
MonitorObserver, monitor, event_handler=self.event_handler)
else:
self.observer = MonitorObserver(monitor, callback=self.callback)
return self.observer
async def _async_start_monitor(self) -> None:
"""Start monitoring hardware with pyudev."""
if not sys.platform.startswith("linux"):
return
info = await system_info.async_get_system_info(self.hass)
if info.get("docker"):
return
from pyudev import ( # pylint: disable=import-outside-toplevel
Context, Monitor, MonitorObserver,
)
try:
context = Context()
except (ImportError, OSError):
return
monitor = Monitor.from_netlink(context)
try:
monitor.filter_by(subsystem="tty")
except ValueError as ex: # this fails on WSL
_LOGGER.debug(
"Unable to setup pyudev filtering; This is expected on WSL: %s",
ex)
return
observer = MonitorObserver(monitor,
callback=self._device_discovered,
name="usb-observer")
observer.start()
self.hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP,
lambda event: observer.stop())
self.observer_active = True
def _init_udev_monitor(self):
self._udev_context = Context()
udev_monitor = Monitor.from_netlink(self._udev_context)
udev_monitor.filter_by(subsystem='hid')
self._udev_observer = MonitorObserver(udev_monitor,
callback=self._udev_input_event,
name='device-monitor')
def start(self):
self.observer = MonitorObserver(self.monitor,
callback=self.start_monitor,
name='monitor-usb-inhibitor')
# For the lock screen (the usb inhibit will continue to run until
# a signal is received -- that would tell the screen unlocked)
# Form the dict with the known devices
if self.flag_known_devices:
self.get_known_devices()
# Initial devices not formed - currently not used
#self.form_initial_devices()
with open('/sys/bus/usb/drivers_autoprobe', 'wt') as f_out:
f_out.write("0")
print("Start monitoring!")
if not self.running_mode_cont:
proc = self.start_process()
print("Runs with a given command mode")
self.observer.start()
while proc.poll() is None:
continue
# For continuous mode must be called manually the stop command
else:
# For testing purposes one can let False and then run the inhibit
# in continuous mode to see the output of it
self.observer.daemon = False
self.observer.start()
print("Runs in continuous mode")
def __init__(self, player):
try:
self.player = player
# Create a context, create monitor at kernel level, select devices
context = Context()
monitor = Monitor.from_netlink(context)
monitor.filter_by(subsystem='input')
self.observer = MonitorObserver(monitor, self.usb_event_callback, name="keyboard")
self.observer.start()
self.pressed = False # Stores state of press
# Check if there is already a keyboard attached
for device in context.list_devices(subsystem='input'):
if device.get('ID_INPUT_KEYBOARD') == '1':
if device.get('DEVNAME') != None:
device_name = InputDevice(device.get('DEVNAME'))
thread = threading.Thread(target=self.keyboard_event, args=(device_name,), daemon=True)
thread.start()
continue
except Exception as ex:
print('Keyboard Control: Error starting: ' + str(ex))
def startUdevMonitor(self, callback):
observer_name = self.MODULE_ID + '-observer'
logger.debug('Setting up udev monitor: %s' % observer_name)
self.udev_observer = MonitorObserver(self.udev_monitor,
callback=callback,
name=observer_name)
self.udev_observer.start()
def start_observer(self):
""" Start plug/unplug event observer """
monitor = Monitor.from_netlink(self.context)
monitor.filter_by(subsystem="block", device_type="partition")
self.observer = MonitorObserver(monitor, callback=self.usb_event_handler)
self.observer.start()
logging.debug("Started USB drive plug/unplug observer")
def __registerUdevCallback(self):
context = pyudev.Context()
monitor = Monitor.from_netlink(context)
monitor.filter_by(subsystem='block')
observer = MonitorObserver(monitor,
callback=self.__checkUdevEvent,
name='monitor-observer')
observer.start()
def __init__(self, func_name):
"""initialization"""
self.log = getLogger(__name__)
context = Context()
monitor = Monitor.from_netlink(context)
self.observer = MonitorObserver(monitor, callback=func_name,
name='monitor-observer')
self.observer.daemon = False
def initialize():
context = Context()
monitor = Monitor.from_netlink(context)
monitor.filter_by(subsystem='tty')
observer = MonitorObserver(monitor,
callback=print_device_event,
name='monitor-observer')
observer.daemon
observer.start()
def add_device_observer(self, handler):
monitor = Monitor.from_netlink(self.context)
monitor.filter_by("hidraw")
def trigger_event(action, device):
if action != 'add': return
dev = HidrawBackend.catchHidrawDevice(device)
if dev is None: return
return handler(self.constructDevice(dev))
observer = MonitorObserver(monitor, trigger_event)
return observer
def startListener():
# create a context, create monitor at kernel level, select devices
context = Context()
monitor = Monitor.from_netlink(context)
monitor.filter_by(subsystem='block')
observer = MonitorObserver(monitor, usbEventCallback, name="usbdev")
# set this as the main thread
observer.setDaemon(False)
observer.start()
return observer
def __init__(self):
self.context = Context()
self.monitor = Monitor.from_netlink(self.context)
self.monitor.filter_by('power_supply')
self.percent_callback = None
self.status_callback = None
(self.battery, self.line_power) = self.find_devices()
if not self.battery:
raise BatteryNotFoundError()
if not self.line_power:
raise LinePowerNotFoundError()
self.last_percent = -1
self.last_status = None
def on_udev_event(device):
if device == self.battery:
self.battery = device
percent = self.get_percent()
if percent != self.last_percent:
self.last_percent = percent
if self.percent_callback:
GLib.idle_add(self.percent_callback, percent)
elif device == self.line_power:
self.line_power = device
status = self.get_status()
if status != self.last_status:
self.last_status = status
if self.status_callback:
GLib.idle_add(self.status_callback, status)
# XXX I can't get udev (or acpi) to give me battery discharge events
# without requiring system configuration so we have to poll
interval = 20000
def poll_udev():
battery = Device.from_path(self.context, self.battery.device_path)
on_udev_event(battery)
GLib.timeout_add(interval, poll_udev)
GLib.timeout_add(interval, poll_udev)
self.observer = MonitorObserver(self.monitor, callback=on_udev_event)
self.observer.start()
def main():
lcd.lcd_init() #initialize lcd display in preparation for sending messages
setConfiguration(
) #query configuration and set remote properties for testing against
context = Context()
monitor = Monitor.from_netlink(context)
monitor.filter_by(subsystem='tty')
observer = MonitorObserver(monitor, device_event)
observer.start()
while True:
n = input("Jeelink Tester v 1.0 type 'stop' to end\n")
if n == 'stop':
observer.stop()
lcd.cleanup()
break
def start_inhibit(self):
self.notification = self.notifier.get_dbus_method('Notify', \
'org.freedesktop.Notifications')
self.observer = MonitorObserver(self.monitor,
callback=self.device_detected,
name='monitor-usb-session')
self.notifier.connect_to_signal('ActionInvoked',
self.action_new_device)
self.observer.daemon = True
self.observer.start()
print("Start monitoring Dbus session message")
self.usb_blocker.get_dbus_method('start',
'org.gnome.USBBlocker.inhibit')()
def __init__(self, *args, **kwargs):
QtWidgets.QMainWindow.__init__(self, *args, **kwargs)
self.setupUi(self)
self.threadpool=QThreadPool()
#Controller to manage Arduino
self.arduinoController=arduinoController(self.threadpool)
self.selectedPort=''
#TODO conect arduinoController signals to MainWindow slots
#levantamos el detector de coneccion/desconeccion
self.context = Context()
self.monitor = Monitor.from_netlink(self.context)
self.monitor.filter_by(subsystem='tty')
self.observer = MonitorObserver(self.monitor, callback=self.eventDetected, name='monitor-observer')
self.observer.daemon
self.observer.start()
self.ttyDeviceEvent.connect(self.onTtyDeviceEvent)
logger.info("MonitorObserver started")
self.onLoadWindow()
def __init__(self,
serial_num,
obj,
refresh=0,
baudrate=115200,
bytesize=8,
parity='N',
stopbits=2,
timeout=400,
debug=False):
# Name and type of the connection peer
self.name = ''
self.type = ''
self.serial_num = serial_num
self.object = obj
self.baudrate = baudrate
self.bytesize = bytesize
self.parity = parity
self.stopbits = stopbits
self.timeout = timeout
self._debug = debug
if refresh > 0:
self._refresh = refresh
self._updateTimer = LoopingCall(self.update)
context = Context()
for device in context.list_devices(subsystem='tty'):
if device.get('ID_SERIAL_SHORT') == self.serial_num:
self._devname = device['DEVNAME']
self.Connect()
cm = Monitor.from_netlink(context)
cm.filter_by(subsystem='tty')
observer = MonitorObserver(cm,
callback=self.ConnectionMCallBack,
name='monitor-observer')
observer.start()
def __init__(self, serial_num, obj, refresh=0, baudrate=115200):
# Name and type of the connection peer
self.name = ''
self.type = ''
self.object = obj
self.baudrate = baudrate
self.serial_num = serial_num
self.devpath = ''
if refresh > 0:
self._refresh = refresh
self.device = pylibftdi.Device(mode='b',
device_id=self.serial_num,
lazy_open=True)
self.device._baudrate = self.baudrate
self._updateTimer = LoopingCall(self.update)
self._updateTimer.start(self._refresh)
self._readTimer = LoopingCall(self.read)
self._readTimer.start(self._refresh / 10)
# the following will start a small daemon to monitor the connection and call ConnectionMade and ConnectionLost
# pyftdi doesn't seem to support this so this pyudev daemon is necessary
context = Context()
# find out whether device is already connected and if that is the case open ftdi connection
for device in context.list_devices(subsystem='usb'):
if device.get('ID_SERIAL_SHORT') == self.serial_num:
for ch in device.children:
if 'tty' not in ch.get('DEVPATH'):
self.devpath = ch.get('DEVPATH')
self.ConnectionMade()
cm = Monitor.from_netlink(context)
cm.filter_by(subsystem='usb')
observer = MonitorObserver(cm,
callback=self.ConnectionMCallBack,
name='monitor-observer')
observer.start()
def handle_print_usb_events():
def print_usb_events(action, device):
string_to_print = '{} - {}'.format(action, device)
for key in device.keys():
string_to_print += '\n {}: {}'.format(key, device.get(key, ''))
print(string_to_print)
# Setup the code for monitoring USB events
context = Context()
monitor = Monitor.from_netlink(context)
monitor.filter_by(subsystem='usb')
observer = MonitorObserver(monitor,
print_usb_events,
name='kamvas-usb-monitor')
# This is needed to prevent the main thread from finishing which would close the process
# and nothing will be displayed
observer.daemon = False
# Start monitoring USB events asynchronously
observer.start()
def start_listener(self):
"""Create a context, create monitor at kernel level, select devices"""
context = Context()
monitor = Monitor.from_netlink(context)
monitor.filter_by(subsystem='block')
observer = MonitorObserver(monitor,
self.event_callback,
name="storage_monitor")
observer.start()
# Check if there is already a usb attached
for device in context.list_devices(subsystem='block',
DEVTYPE='partition'):
if re.search('/dev/s.+', device.get('DEVNAME')):
self.usb_add(device)
continue
# Check if there is already an sd attached
for device in context.list_devices(subsystem='block',
DEVTYPE='partition'):
if re.search('/dev/mmcblk1p1', device.get('DEVNAME')):
self.sd_add(device)
continue
def run_main():
global args
args = get_args()
# Setup the code for monitoring USB events
context = Context()
monitor = Monitor.from_netlink(context)
monitor.filter_by(subsystem='usb')
# Start monitoring USB events asynchronously
observer = MonitorObserver(monitor,
handle_usb_event,
name='monitor-observer')
observer.daemon = False
observer.start()
# Try to start the driver. It will raise an error if the USB device is not available
try:
evdev_is_running = True
run_evdev()
except:
if not args['--quiet-mode']:
print('Error occured')
evdev_is_running = False
def get_observer():
ctx = Context()
mon = Monitor.from_netlink(ctx)
mon.filter_by('block')
return MonitorObserver(mon, callback=callback)
def __init__(self,
verbose=False,
log_dir=None,
console_log=False,
run_dir=None,
config_file=None,
test_dir=None):
# Check if process exists
exit_code = subprocess.call(['pgrep', 'razer-service'],
stderr=subprocess.DEVNULL,
stdout=subprocess.DEVNULL)
if exit_code == 0:
print("Daemon already exists. Please stop that one.",
file=sys.stderr)
exit(-1)
setproctitle.setproctitle('razer-service')
# Expanding ~ as python doesnt do it by default, also creating dirs if needed
if log_dir is not None:
log_dir = os.path.expanduser(log_dir)
os.makedirs(log_dir, mode=0o750, exist_ok=True)
if run_dir is not None:
run_dir = os.path.expanduser(run_dir)
os.makedirs(run_dir, mode=0o750, exist_ok=True)
if config_file is not None:
config_file = os.path.expanduser(config_file)
os.makedirs(os.path.dirname(config_file),
mode=0o750,
exist_ok=True)
self._test_dir = test_dir
self._data_dir = run_dir
self._config_file = config_file
self._config = configparser.ConfigParser()
self.read_config(config_file)
# Setup DBus to use gobject main loop
dbus.mainloop.glib.threads_init()
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
DBusService.__init__(self, self.BUS_PATH, '/org/razer')
self._init_signals()
self._main_loop = GObject.MainLoop()
# Listen for input events from udev
self._udev_context = Context()
udev_monitor = Monitor.from_netlink(self._udev_context)
udev_monitor.filter_by(subsystem='input')
self._udev_observer = MonitorObserver(udev_monitor,
callback=self._udev_input_event,
name='device-monitor')
# Logging
logging_level = logging.INFO
if verbose or self._config.getboolean('General', 'verbose_logging'):
logging_level = logging.DEBUG
self.logger = logging.getLogger('razer')
self.logger.setLevel(logging_level)
formatter = logging.Formatter(
'%(asctime)s | %(name)-30s | %(levelname)-8s | %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
# Dont propagate to default logger
self.logger.propagate = 0
if console_log:
console_logger = logging.StreamHandler()
console_logger.setLevel(logging_level)
console_logger.setFormatter(formatter)
self.logger.addHandler(console_logger)
if log_dir is not None:
log_file = os.path.join(log_dir, 'razer.log')
file_logger = logging.handlers.RotatingFileHandler(
log_file, maxBytes=16777216, backupCount=10) # 16MiB
file_logger.setLevel(logging_level)
file_logger.setFormatter(formatter)
self.logger.addHandler(file_logger)
self.logger.info("Initialising Daemon (v%s). Pid: %d", __version__,
os.getpid())
# Setup screensaver thread
self._screensaver_thread = ScreensaverThread(
self,
active=self._config.getboolean('Startup',
'devices_off_on_screensaver'))
self._screensaver_thread.start()
self._razer_devices = DeviceCollection()
self._load_devices(first_run=True)
# Add DBus methods
self.logger.info("Adding razer.devices.getDevices method to DBus")
self.add_dbus_method('razer.devices',
'getDevices',
self.get_serial_list,
out_signature='as')
self.logger.info(
"Adding razer.devices.enableTurnOffOnScreensaver method to DBus")
self.add_dbus_method('razer.devices', 'enableTurnOffOnScreensaver',
self.enable_turn_off_on_screensaver)
self.logger.info(
"Adding razer.devices.disableTurnOffOnScreensaver method to DBus")
self.add_dbus_method('razer.devices', 'disableTurnOffOnScreensaver',
self.disable_turn_off_on_screensaver)
self.logger.info("Adding razer.devices.syncEffects method to DBus")
self.add_dbus_method('razer.devices',
'syncEffects',
self.sync_effects,
in_signature='b')
self.logger.info("Adding razer.daemon.version method to DBus")
self.add_dbus_method('razer.daemon',
'version',
self.version,
out_signature='s')
self.logger.info("Adding razer.daemon.stop method to DBus")
self.add_dbus_method('razer.daemon', 'stop', self.stop)
# TODO remove
self.sync_effects(
self._config.getboolean('Startup', 'sync_effects_enabled'))
elif (action == 'remove') and (device.get('ID_INPUT_KEYBOARD') == '1'):
print('Keyboard: input remove')
# def key_input(key_pressed):
# """Handles keyboard release"""
# print('Keyboard Control: Key released: ' + key_pressed.name)
# if key_pressed.name == 'space':
# print('shit')
async def keyboard_event(device):
try:
async for event in device.async_read_loop():
if event.type == ecodes.EV_KEY:
print(ecodes.KEY[event.code])
except Exception as ex:
print('bum: ' + str(ex))
loop = asyncio.get_event_loop()
# Create a context, create monitor at kernel level, select devices
context = Context()
monitor = Monitor.from_netlink(context)
monitor.filter_by(subsystem='input')
observer = MonitorObserver(monitor, usb_event_callback, name="keyboard")
observer.start()
while 1:
time.sleep(10)
def run(self):
observer = MonitorObserver(monitor, self.udev_action)
observer.daemon = True
observer.start()
def __init__(self,
verbose=False,
log_dir=None,
console_log=False,
run_dir=None,
config_file=None,
test_dir=None):
# Check if process exists and is not running as current user
proc = subprocess.Popen(['pgrep', 'razer-daemon'],
stderr=subprocess.DEVNULL,
stdout=subprocess.PIPE)
stdout = proc.communicate()[0]
# If 0 there are other services running
if proc.returncode == 0:
current_uid = str(os.getuid())
# Loop through other running daemon's
pids = stdout.decode().strip('\n').split('\n')
for pid in pids:
# Open status file in /proc to get uid
with open('/proc/{0}/status'.format(pid), 'r') as status_file:
for line in status_file:
# Looking for
# Uid: 1000 1000 1000 1000
# If they match current pid, then we have a daemon running as this user
if line.startswith('Uid:') and line.strip(
'\n').split()[-1] == current_uid:
print(
"Daemon already exists. Please stop that one.",
file=sys.stderr)
sys.exit(-1)
setproctitle.setproctitle('razer-daemon')
# Expanding ~ as python doesnt do it by default, also creating dirs if needed
if log_dir is not None:
log_dir = os.path.expanduser(log_dir)
if run_dir is not None:
run_dir = os.path.expanduser(run_dir)
if config_file is not None:
config_file = os.path.expanduser(config_file)
self._test_dir = test_dir
self._run_dir = run_dir
self._config_file = config_file
self._config = configparser.ConfigParser()
self.read_config(config_file)
# Setup DBus to use gobject main loop
dbus.mainloop.glib.threads_init()
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
DBusService.__init__(self, self.BUS_PATH, '/org/razer')
self._init_signals()
self._main_loop = GObject.MainLoop()
# Listen for input events from udev
self._udev_context = Context()
udev_monitor = Monitor.from_netlink(self._udev_context)
udev_monitor.filter_by(subsystem='hid')
self._udev_observer = MonitorObserver(udev_monitor,
callback=self._udev_input_event,
name='device-monitor')
# Logging
logging_level = logging.INFO
if verbose or self._config.getboolean('General', 'verbose_logging'):
logging_level = logging.DEBUG
self.logger = logging.getLogger('razer')
self.logger.setLevel(logging_level)
formatter = logging.Formatter(
'%(asctime)s | %(name)-30s | %(levelname)-8s | %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
# Dont propagate to default logger
self.logger.propagate = 0
if console_log:
console_logger = logging.StreamHandler()
console_logger.setLevel(logging_level)
console_logger.setFormatter(formatter)
self.logger.addHandler(console_logger)
if log_dir is not None:
log_file = os.path.join(log_dir, 'razer.log')
file_logger = logging.handlers.RotatingFileHandler(
log_file, maxBytes=16777216, backupCount=10) # 16MiB
file_logger.setLevel(logging_level)
file_logger.setFormatter(formatter)
self.logger.addHandler(file_logger)
# Load Classes
self._device_classes = razer_daemon.hardware.get_device_classes()
self.logger.info("Initialising Daemon (v%s). Pid: %d", __version__,
os.getpid())
# Check for plugdev group
try:
plugdev_group = grp.getgrnam('plugdev')
if getpass.getuser() not in plugdev_group.gr_mem:
self.logger.critical(
"User is not a member of the plugdev group")
sys.exit(1)
except KeyError:
self.logger.warning(
"Could not check if user is a member of the plugdev group. Continuing..."
)
self._screensaver_monitor = ScreensaverMonitor(self)
self._screensaver_monitor.monitoring = self._config.getboolean(
'Startup', 'devices_off_on_screensaver')
self._razer_devices = DeviceCollection()
self._load_devices(first_run=True)
# Add DBus methods
self.logger.info("Adding razer.devices.getDevices method to DBus")
self.add_dbus_method('razer.devices',
'getDevices',
self.get_serial_list,
out_signature='as')
self.logger.info("Adding razer.daemon.supportedDevices method to DBus")
self.add_dbus_method('razer.daemon',
'supportedDevices',
self.supported_devices,
out_signature='s')
self.logger.info(
"Adding razer.devices.enableTurnOffOnScreensaver method to DBus")
self.add_dbus_method('razer.devices',
'enableTurnOffOnScreensaver',
self.enable_turn_off_on_screensaver,
in_signature='b')
self.logger.info("Adding razer.devices.syncEffects method to DBus")
self.add_dbus_method('razer.devices',
'getOffOnScreensaver',
self.get_off_on_screensaver,
out_signature='b')
self.logger.info("Adding razer.devices.syncEffects method to DBus")
self.add_dbus_method('razer.devices',
'syncEffects',
self.sync_effects,
in_signature='b')
self.logger.info("Adding razer.devices.syncEffects method to DBus")
self.add_dbus_method('razer.devices',
'getSyncEffects',
self.get_sync_effects,
out_signature='b')
self.logger.info("Adding razer.daemon.version method to DBus")
self.add_dbus_method('razer.daemon',
'version',
self.version,
out_signature='s')
self.logger.info("Adding razer.daemon.stop method to DBus")
self.add_dbus_method('razer.daemon', 'stop', self.stop)
# TODO remove
self.sync_effects(
self._config.getboolean('Startup', 'sync_effects_enabled'))
# https://pyudev.readthedocs.io/en/v0.14/api/monitor.html#pyudev.MonitorObserver
from pyudev import Context, Monitor, MonitorObserver
from time import sleep
context = Context()
monitor = Monitor.from_netlink(context)
monitor.filter_by(subsystem='input')
def print_device_event(action, device):
print('background event {0}: {1}'.format(action, device))
observer = MonitorObserver(monitor,
print_device_event,
name='monitor-observer')
print('Starting obverver')
observer.start()
while True:
sleep(600)
def __init__(self, args: List[str]):
"""
At the moment the very, very long initialization of the main window,
setting up everything.
:param default_path: Use a user defined path as entrypoint. If it's
empty, the home directory of the current user will
be used.
:type default_path: str
"""
super(tfm, self).__init__()
self.setupUi(self)
self.setWindowIcon(QIcon.fromTheme('system-file-manager'))
self.clipboard = QApplication.clipboard()
self.marked_to_cut = []
self.back_stack = stack()
self.forward_stack = stack()
self.config_dir = os.path.join(
QStandardPaths.writableLocation(
QStandardPaths().ConfigLocation),
type(self).__name__)
self.current_path = utility.handle_args(args)
self.default_path = self.current_path
self.threadpool = QThreadPool()
# MAIN VIEW #
# set up QFileSystemModel
self.filesystem = QFileSystemModel()
self.filesystem.setRootPath(self.current_path)
self.filesystem.setReadOnly(False)
# connect QFileSystemModel to View
self.table_view.setModel(self.filesystem)
self.table_view.setRootIndex(
self.filesystem.index(self.current_path))
# set up header
self.horizontal_header = self.table_view.horizontalHeader()
self.horizontal_header.setSectionsMovable(True)
# name
self.horizontal_header.resizeSection(0, 200)
# size
self.horizontal_header.resizeSection(1, 100)
# type
self.horizontal_header.resizeSection(2, 100)
# FS TREE #
# create seperate FileSystemModel for the fs tree
self.fs_tree_model = QFileSystemModel()
self.fs_tree_model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
self.fs_tree_model.setRootPath(QDir.rootPath())
# connect model to view
self.fs_tree.setModel(self.fs_tree_model)
# hide unneeded columns
for column in range(1, self.fs_tree.header().count()):
self.fs_tree.hideColumn(column)
# expand root item
self.fs_tree.expand(self.fs_tree_model.index(0, 0))
# BOOKMARKS #
self.bookmarks = bm(path_to_bookmark_file=os.path.join(self.config_dir,
'bookmarks'))
self.bookmark_view.setModel(self.bookmarks)
# MOUNTS #
self.udev_context = Context()
self.mounts = mounts_model(context=self.udev_context)
self.mounts_view.setModel(self.mounts)
udev_monitor = Monitor.from_netlink(self.udev_context)
udev_monitor.filter_by(subsystem='block', device_type='partition')
udev_observer = MonitorObserver(udev_monitor,
self.devices_changed)
udev_observer.start()
# STATUSBAR #
# TODO: dir info
self.item_info = QLabel()
# self.dir_info = QLabel()
self.part_info = QLabel()
self.statusbar.addPermanentWidget(self.item_info)
# self.statusbar.addPermanentWidget(self.dir_info)
self.statusbar.addPermanentWidget(self.part_info)
self.part_info.setText(utility.part_info(self.current_path))
# TOOLBAR #
# initially disable back/forward navigation
self.action_back.setEnabled(False)
self.action_forward.setEnabled(False)
# main menu
self.main_menu = QMenu()
self.main_menu.addAction(self.action_show_hidden)
self.menu_button = QToolButton()
self.menu_button.setMenu(self.main_menu)
self.menu_button.setPopupMode(QToolButton().InstantPopup)
self.menu_button.setDefaultAction(self.action_menu)
self.toolbar.insertWidget(self.action_back, self.menu_button)
# adress bar
self.adressbar = QLineEdit()
self.adressbar.setText(self.current_path)
self.toolbar.insertWidget(self.action_go, self.adressbar)
# menu for new file or directory
self.new_menu = QMenu()
self.new_menu.addAction(self.action_new_dir)
self.new_menu.addAction(self.action_new_file)
self.new_button = QToolButton()
self.new_button.setMenu(self.new_menu)
self.new_button.setPopupMode(QToolButton().MenuButtonPopup)
self.new_button.setDefaultAction(self.action_new_dir)
self.toolbar.insertWidget(self.action_back, self.new_button)
self.connect_actions_to_events()
self.set_shortcuts()
self.set_icons()
self.set_context_menus()
def __init__(self,
obj,
devname,
refresh=0,
baudrate=115200,
bytesize=8,
parity='N',
stopbits=2,
timeout=400,
debug=False,
window_size=8,
rx_window_size=16,
transport_fifo_size=100,
ack_retransmit_timeout_ms=25,
frame_retransmit_timeout_ms=50):
# Name and type of the connection peer
self.name = ''
self.type = ''
self._devname = devname
self.object = obj
self.baudrate = baudrate
self.bytesize = bytesize
self.parity = parity
self.stopbits = stopbits
self.timeout = timeout
self.transport_fifo_size = transport_fifo_size
self.ack_retransmit_timeout_ms = ack_retransmit_timeout_ms
self.max_window_size = window_size
self.frame_retransmit_timeout_ms = frame_retransmit_timeout_ms
self.rx_window_size = rx_window_size
# State of transport FIFO
self._transport_fifo = None
self._last_sent_ack_time_ms = None
# State for receiving a MIN frame
self._rx_frame_buf = bytearray()
self._rx_header_bytes_seen = 0
self._rx_frame_state = self.SEARCHING_FOR_SOF
self._rx_frame_checksum = 0
self._rx_frame_id_control = 0
self._rx_frame_seq = 0
self._rx_frame_length = 0
self._rx_control = 0
self._stashed_rx_dict = {}
self._rn = 0 # Sequence number expected to be received next
self._sn_min = 0 # Sequence number of first frame currently in the sending window
self._sn_max = 0 # Next sequence number to use for sending a frame
self.source = {} # sequence <--> sommand source linking
self._nack_outstanding = None
self._transport_fifo_reset()
if refresh > 0:
self._refresh = refresh
self._updateTimer = LoopingCall(self.update)
self._updateTimer.start(self._refresh)
context = Context()
for device in context.list_devices(subsystem='tty'):
if 'DEVLINKS' in device.keys() and self._devname in device.get(
'DEVLINKS'):
self.Connect()
self.connectionMade()
cm = Monitor.from_netlink(context)
cm.filter_by(subsystem='tty')
observer = MonitorObserver(cm,
callback=self.ConnectionMCallBack,
name='monitor-observer')
observer.start()
break
if not found:
if d in __cached_devices:
__cached_devices.remove(d)
for l in device_removed_listeners:
l(d)
break
try:
from pyudev import Context, Monitor, MonitorObserver
__context = Context()
__monitor = Monitor.from_netlink(__context)
def handle_device_event(device=None):
if device.action == "add":
__device_added(device)
if action == "removed":
__device_removed(device)
__observer = MonitorObserver(__monitor, callback=handle_device_event, name='monitor-observer')
find_all_devices()
have_udev = True
__monitor.start()
except Exception as e:
logger.info("Failed to get PyUDev context, hot plugging support not available", exc_info = e)
if __name__ == "__main__":
for device in find_all_devices():
print(str(device))
