| Current File : /home/mmdealscpanel/yummmdeals.com/pyudev.tar |
__init__.py 0000644 00000004676 15035142004 0006664 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2010, 2011, 2012 Sebastian Wiesner <lunaryorn@gmail.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev
======
A binding to libudev.
The :class:`Context` provides the connection to the udev device database
and enumerates devices. Individual devices are represented by the
:class:`Device` class.
Device monitoring is provided by :class:`Monitor` and
:class:`MonitorObserver`. With :mod:`pyudev.pyqt4`, :mod:`pyudev.pyside`,
:mod:`pyudev.glib` and :mod:`pyudev.wx` device monitoring can be integrated
into the event loop of various GUI toolkits.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from pyudev.device import Attributes
from pyudev.device import Device
from pyudev.device import Devices
from pyudev.device import DeviceNotFoundAtPathError
from pyudev.device import DeviceNotFoundByFileError
from pyudev.device import DeviceNotFoundByNameError
from pyudev.device import DeviceNotFoundByNumberError
from pyudev.device import DeviceNotFoundError
from pyudev.device import DeviceNotFoundInEnvironmentError
from pyudev.device import Tags
from pyudev.discover import DeviceFileHypothesis
from pyudev.discover import DeviceNameHypothesis
from pyudev.discover import DeviceNumberHypothesis
from pyudev.discover import DevicePathHypothesis
from pyudev.discover import Discovery
from pyudev.core import Context
from pyudev.core import Enumerator
from pyudev.monitor import Monitor
from pyudev.monitor import MonitorObserver
from pyudev.version import __version__
from pyudev.version import __version_info__
from pyudev._util import udev_version
discover.py 0000644 00000026364 15035142004 0006741 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2015 mulhern <amulhern@redhat.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev.discover
===============
Tools to discover a device given limited information.
.. moduleauthor:: mulhern <amulhern@redhat.com>
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import abc
import functools
import os
import re
import six
from pyudev.device import Devices
from pyudev.device import DeviceNotFoundError
def wrap_exception(func):
"""
Allow Device discovery methods to return None instead of raising an
exception.
"""
@functools.wraps(func)
def the_func(*args, **kwargs):
"""
Returns result of calling ``func`` on ``args``, ``kwargs``.
Returns None if ``func`` raises :exc:`DeviceNotFoundError`.
"""
try:
return func(*args, **kwargs)
except DeviceNotFoundError:
return None
return the_func
@six.add_metaclass(abc.ABCMeta)
class Hypothesis(object):
"""
Represents a hypothesis about the meaning of the device identifier.
"""
@classmethod
@abc.abstractmethod
def match(cls, value): # pragma: no cover
"""
Match the given string according to the hypothesis.
The purpose of this method is to obtain a value corresponding to
``value`` if that is possible. It may use a regular expression, but
in general it should just return ``value`` and let the lookup method
sort out the rest.
:param str value: the string to inspect
:returns: the matched thing or None if unmatched
:rtype: the type of lookup's key parameter or NoneType
"""
raise NotImplementedError()
@classmethod
@abc.abstractmethod
def lookup(cls, context, key): # pragma: no cover
"""
Lookup the given string according to the hypothesis.
:param Context context: the pyudev context
:param key: a key with which to lookup the device
:type key: the type of match's return value if not None
:returns: a list of Devices obtained
:rtype: frozenset of :class:`Device`
"""
raise NotImplementedError()
@classmethod
def setup(cls, context):
"""
A potentially expensive method that may allow an :class:`Hypothesis`
to find devices more rapidly or to find a device that it would
otherwise miss.
:param Context context: the pyudev context
"""
pass
@classmethod
def get_devices(cls, context, value):
"""
Get any devices that may correspond to the given string.
:param Context context: the pyudev context
:param str value: the value to look for
:returns: a list of devices obtained
:rtype: set of :class:`Device`
"""
key = cls.match(value)
return cls.lookup(context, key) if key is not None else frozenset()
class DeviceNumberHypothesis(Hypothesis):
"""
Represents the hypothesis that the device is a device number.
The device may be separated into major/minor number or a composite number.
"""
@classmethod
def _match_major_minor(cls, value):
"""
Match the number under the assumption that it is a major,minor pair.
:param str value: value to match
:returns: the device number or None
:rtype: int or NoneType
"""
major_minor_re = re.compile(
r'^(?P<major>\d+)(\D+)(?P<minor>\d+)$'
)
match = major_minor_re.match(value)
return match and os.makedev(
int(match.group('major')),
int(match.group('minor'))
)
@classmethod
def _match_number(cls, value):
"""
Match the number under the assumption that it is a single number.
:param str value: value to match
:returns: the device number or None
:rtype: int or NoneType
"""
number_re = re.compile(r'^(?P<number>\d+)$')
match = number_re.match(value)
return match and int(match.group('number'))
@classmethod
def match(cls, value):
"""
Match the number under the assumption that it is a device number.
:returns: the device number or None
:rtype: int or NoneType
"""
return cls._match_major_minor(value) or cls._match_number(value)
@classmethod
def find_subsystems(cls, context):
"""
Find subsystems in /sys/dev.
:param Context context: the context
:returns: a lis of available subsystems
:rtype: list of str
"""
sys_path = context.sys_path
return os.listdir(os.path.join(sys_path, 'dev'))
@classmethod
def lookup(cls, context, key):
"""
Lookup by the device number.
:param Context context: the context
:param int key: the device number
:returns: a list of matching devices
:rtype: frozenset of :class:`Device`
"""
func = wrap_exception(Devices.from_device_number)
res = (func(context, s, key) for s in cls.find_subsystems(context))
return frozenset(r for r in res if r is not None)
class DevicePathHypothesis(Hypothesis):
"""
Discover the device assuming the identifier is a device path.
"""
@classmethod
def match(cls, value):
"""
Match ``value`` under the assumption that it is a device path.
:returns: the device path or None
:rtype: str or NoneType
"""
return value
@classmethod
def lookup(cls, context, key):
"""
Lookup by the path.
:param Context context: the context
:param str key: the device path
:returns: a list of matching devices
:rtype: frozenset of :class:`Device`
"""
res = wrap_exception(Devices.from_path)(context, key)
return frozenset((res,)) if res is not None else frozenset()
class DeviceNameHypothesis(Hypothesis):
"""
Discover the device assuming the input is a device name.
Try every available subsystem.
"""
@classmethod
def find_subsystems(cls, context):
"""
Find all subsystems in sysfs.
:param Context context: the context
:rtype: frozenset
:returns: subsystems in sysfs
"""
sys_path = context.sys_path
dirnames = ('bus', 'class', 'subsystem')
absnames = (os.path.join(sys_path, name) for name in dirnames)
realnames = (d for d in absnames if os.path.isdir(d))
return frozenset(n for d in realnames for n in os.listdir(d))
@classmethod
def match(cls, value):
"""
Match ``value`` under the assumption that it is a device name.
:returns: the device path or None
:rtype: str or NoneType
"""
return value
@classmethod
def lookup(cls, context, key):
"""
Lookup by the path.
:param Context context: the context
:param str key: the device path
:returns: a list of matching devices
:rtype: frozenset of :class:`Device`
"""
func = wrap_exception(Devices.from_name)
res = (func(context, s, key) for s in cls.find_subsystems(context))
return frozenset(r for r in res if r is not None)
class DeviceFileHypothesis(Hypothesis):
"""
Discover the device assuming the value is some portion of a device file.
The device file may be a link to a device node.
"""
_LINK_DIRS = [
'/dev',
'/dev/disk/by-id',
'/dev/disk/by-label',
'/dev/disk/by-partlabel',
'/dev/disk/by-partuuid',
'/dev/disk/by-path',
'/dev/disk/by-uuid',
'/dev/input/by-path',
'/dev/mapper',
'/dev/md',
'/dev/vg'
]
@classmethod
def get_link_dirs(cls, context):
"""
Get all directories that may contain links to device nodes.
This method checks the device links of every device, so it is very
expensive.
:param Context context: the context
:returns: a sorted list of directories that contain device links
:rtype: list
"""
devices = context.list_devices()
devices_with_links = (d for d in devices if list(d.device_links))
links = (l for d in devices_with_links for l in d.device_links)
return sorted(set(os.path.dirname(l) for l in links))
@classmethod
def setup(cls, context):
"""
Set the link directories to be used when discovering by file.
Uses `get_link_dirs`, so is as expensive as it is.
:param Context context: the context
"""
cls._LINK_DIRS = cls.get_link_dirs(context)
@classmethod
def match(cls, value):
return value
@classmethod
def lookup(cls, context, key):
"""
Lookup the device under the assumption that the key is part of
the name of a device file.
:param Context context: the context
:param str key: a portion of the device file name
It is assumed that either it is the whole name of the device file
or it is the basename.
A device file may be a device node or a device link.
"""
func = wrap_exception(Devices.from_device_file)
if '/' in key:
device = func(context, key)
return frozenset((device,)) if device is not None else frozenset()
else:
files = (os.path.join(ld, key) for ld in cls._LINK_DIRS)
devices = (func(context, f) for f in files)
return frozenset(d for d in devices if d is not None)
class Discovery(object):
# pylint: disable=too-few-public-methods
"""
Provides discovery methods for devices.
"""
_HYPOTHESES = [
DeviceFileHypothesis,
DeviceNameHypothesis,
DeviceNumberHypothesis,
DevicePathHypothesis
]
def __init__(self):
self._hypotheses = self._HYPOTHESES
def setup(self, context):
"""
Set up individual hypotheses.
May be an expensive call.
:param Context context: the context
"""
for hyp in self._hypotheses:
hyp.setup(context)
def get_devices(self, context, value):
"""
Get the devices corresponding to value.
:param Context context: the context
:param str value: some identifier of the device
:returns: a list of corresponding devices
:rtype: frozenset of :class:`Device`
"""
return frozenset(
d for h in self._hypotheses for d in h.get_devices(context, value)
)
_util.py 0000644 00000015450 15035142004 0006231 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2010, 2011, 2012 Sebastian Wiesner <lunaryorn@gmail.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev._util
============
Internal utilities
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
"""
from __future__ import (print_function, division, unicode_literals,
absolute_import)
try:
from subprocess import check_output
except ImportError:
from pyudev._compat import check_output
import os
import sys
import stat
import errno
import six
def ensure_byte_string(value):
"""
Return the given ``value`` as bytestring.
If the given ``value`` is not a byte string, but a real unicode string, it
is encoded with the filesystem encoding (as in
:func:`sys.getfilesystemencoding()`).
"""
if not isinstance(value, bytes):
value = value.encode(sys.getfilesystemencoding())
return value
def ensure_unicode_string(value):
"""
Return the given ``value`` as unicode string.
If the given ``value`` is not a unicode string, but a byte string, it is
decoded with the filesystem encoding (as in
:func:`sys.getfilesystemencoding()`).
"""
if not isinstance(value, six.text_type):
value = value.decode(sys.getfilesystemencoding())
return value
def property_value_to_bytes(value):
"""
Return a byte string, which represents the given ``value`` in a way
suitable as raw value of an udev property.
If ``value`` is a boolean object, it is converted to ``'1'`` or ``'0'``,
depending on whether ``value`` is ``True`` or ``False``. If ``value`` is a
byte string already, it is returned unchanged. Anything else is simply
converted to a unicode string, and then passed to
:func:`ensure_byte_string`.
"""
# udev represents boolean values as 1 or 0, therefore an explicit
# conversion to int is required for boolean values
if isinstance(value, bool):
value = int(value)
if isinstance(value, bytes):
return value
else:
return ensure_byte_string(six.text_type(value))
def string_to_bool(value):
"""
Convert the given unicode string ``value`` to a boolean object.
If ``value`` is ``'1'``, ``True`` is returned. If ``value`` is ``'0'``,
``False`` is returned. Any other value raises a
:exc:`~exceptions.ValueError`.
"""
if value not in ('1', '0'):
raise ValueError('Not a boolean value: {0!r}'.format(value))
return value == '1'
def udev_list_iterate(libudev, entry):
"""
Iteration helper for udev list entry objects.
Yield a tuple ``(name, value)``. ``name`` and ``value`` are bytestrings
containing the name and the value of the list entry. The exact contents
depend on the list iterated over.
"""
while entry:
name = libudev.udev_list_entry_get_name(entry)
value = libudev.udev_list_entry_get_value(entry)
yield (name, value)
entry = libudev.udev_list_entry_get_next(entry)
def get_device_type(filename):
"""
Get the device type of a device file.
``filename`` is a string containing the path of a device file.
Return ``'char'`` if ``filename`` is a character device, or ``'block'`` if
``filename`` is a block device. Raise :exc:`~exceptions.ValueError` if
``filename`` is no device file at all. Raise
:exc:`~exceptions.EnvironmentError` if ``filename`` does not exist or if
its metadata was inaccessible.
.. versionadded:: 0.15
"""
mode = os.stat(filename).st_mode
if stat.S_ISCHR(mode):
return 'char'
elif stat.S_ISBLK(mode):
return 'block'
else:
raise ValueError('not a device file: {0!r}'.format(filename))
def eintr_retry_call(func, *args, **kwargs):
"""
Handle interruptions to an interruptible system call.
Run an interruptible system call in a loop and retry if it raises EINTR.
The signal calls that may raise EINTR prior to Python 3.5 are listed in
PEP 0475. Any calls to these functions must be wrapped in eintr_retry_call
in order to handle EINTR returns in older versions of Python.
This function is safe to use under Python 3.5 and newer since the wrapped
function will simply return without raising EINTR.
This function is based on _eintr_retry_call in python's subprocess.py.
"""
# select.error inherits from Exception instead of OSError in Python 2
import select
while True:
try:
return func(*args, **kwargs)
except (OSError, IOError, select.error) as err:
# If this is not an IOError or OSError, it's the old select.error
# type, which means that the errno is only accessible via subscript
if isinstance(err, (OSError, IOError)):
error_code = err.errno
else:
error_code = err.args[0]
if error_code == errno.EINTR:
continue
raise
def udev_version():
"""
Get the version of the underlying udev library.
udev doesn't use a standard major-minor versioning scheme, but instead
labels releases with a single consecutive number. Consequently, the
version number returned by this function is a single integer, and not a
tuple (like for instance the interpreter version in
:data:`sys.version_info`).
As libudev itself does not provide a function to query the version number,
this function calls the ``udevadm`` utility, so be prepared to catch
:exc:`~exceptions.EnvironmentError` and
:exc:`~subprocess.CalledProcessError` if you call this function.
Return the version number as single integer. Raise
:exc:`~exceptions.ValueError`, if the version number retrieved from udev
could not be converted to an integer. Raise
:exc:`~exceptions.EnvironmentError`, if ``udevadm`` was not found, or could
not be executed. Raise :exc:`subprocess.CalledProcessError`, if
``udevadm`` returned a non-zero exit code. On Python 2.7 or newer, the
``output`` attribute of this exception is correctly set.
.. versionadded:: 0.8
"""
output = ensure_unicode_string(check_output(['udevadm', '--version']))
return int(output.strip())
_compat.py 0000644 00000002674 15035142004 0006543 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2011 Sebastian Wiesner <lunaryorn@gmail.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev._compat
==============
Compatibility for Python versions, that lack certain functions.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
"""
from __future__ import (print_function, division, unicode_literals,
absolute_import)
from subprocess import Popen, CalledProcessError, PIPE
def check_output(command):
"""
Compatibility with :func:`subprocess.check_output` from Python 2.7 and
upwards.
"""
proc = Popen(command, stdout=PIPE)
output = proc.communicate()[0]
if proc.returncode != 0:
raise CalledProcessError(proc.returncode, command)
return output
__pycache__/version.cpython-36.opt-1.pyc 0000644 00000001143 15035142004 0014017 0 ustar 00 3
u1�WM � @ sH d Z d Zddjdd� edd � D ��djd
d� ed d� D ��f ZdS ) zx
pyudev.version
==============
Version information.
.. moduleauthor:: mulhern <amulhern@redhat.com>
� � � z%s%s�.c c s | ]}t |�V qd S )N)�str)�.0�x� r � /usr/lib/python3.6/version.py� <genexpr> s r
N� c c s | ]}t |�V qd S )N)r )r r r r r r
s )r r r r )�__doc__Z__version_info__�join� __version__r r r r �<module> s __pycache__/_util.cpython-36.opt-1.pyc 0000644 00000013502 15035142004 0013450 0 ustar 00 3
N�#W( � @ s� d Z ddlmZmZmZmZ yddlmZ W n ek
rL ddl mZ Y nX ddl
Z
ddl Z ddl Z ddl
Z
ddlZdd� Zdd� Zd d
� Zd d � Zd
d� Zdd� Zdd� Zdd� ZdS )z|
pyudev._util
============
Internal utilities
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�print_function�division�unicode_literals�absolute_import)� check_outputNc C s t | t�s| jtj� �} | S )z�
Return the given ``value`` as bytestring.
If the given ``value`` is not a byte string, but a real unicode string, it
is encoded with the filesystem encoding (as in
:func:`sys.getfilesystemencoding()`).
)�
isinstance�bytes�encode�sys�getfilesystemencoding)�value� r
�/usr/lib/python3.6/_util.py�ensure_byte_string- s
r c C s t | tj�s| jtj� �} | S )z�
Return the given ``value`` as unicode string.
If the given ``value`` is not a unicode string, but a byte string, it is
decoded with the filesystem encoding (as in
:func:`sys.getfilesystemencoding()`).
)r �six� text_type�decoder
r )r r
r
r �ensure_unicode_string: s r c C s2 t | t�rt| �} t | t�r | S ttj| ��S dS )a�
Return a byte string, which represents the given ``value`` in a way
suitable as raw value of an udev property.
If ``value`` is a boolean object, it is converted to ``'1'`` or ``'0'``,
depending on whether ``value`` is ``True`` or ``False``. If ``value`` is a
byte string already, it is returned unchanged. Anything else is simply
converted to a unicode string, and then passed to
:func:`ensure_byte_string`.
N)r �bool�intr r r r )r r
r
r �property_value_to_bytesG s
r c C s | dkrt dj| ���| dkS )z�
Convert the given unicode string ``value`` to a boolean object.
If ``value`` is ``'1'``, ``True`` is returned. If ``value`` is ``'0'``,
``False`` is returned. Any other value raises a
:exc:`~exceptions.ValueError`.
�1�0zNot a boolean value: {0!r})r r )�
ValueError�format)r r
r
r �string_to_bool\ s r c c s6 x0|r0| j |�}| j|�}||fV | j|�}qW dS )z�
Iteration helper for udev list entry objects.
Yield a tuple ``(name, value)``. ``name`` and ``value`` are bytestrings
containing the name and the value of the list entry. The exact contents
depend on the list iterated over.
N)Zudev_list_entry_get_nameZudev_list_entry_get_valueZudev_list_entry_get_next)Zlibudev�entry�namer r
r
r �udev_list_iteratei s
r c C s: t j| �j}tj|�rdS tj|�r(dS tdj| ���dS )a�
Get the device type of a device file.
``filename`` is a string containing the path of a device file.
Return ``'char'`` if ``filename`` is a character device, or ``'block'`` if
``filename`` is a block device. Raise :exc:`~exceptions.ValueError` if
``filename`` is no device file at all. Raise
:exc:`~exceptions.EnvironmentError` if ``filename`` does not exist or if
its metadata was inaccessible.
.. versionadded:: 0.15
�char�blockznot a device file: {0!r}N)�os�stat�st_mode�S_ISCHR�S_ISBLKr r )�filename�moder
r
r �get_device_typex s
r( c O sv ddl }xhy
| ||�S tt|jfk
rl } z4t|ttf�rD|j}n
|jd }|tjkrZw
� W Y dd}~X q
X q
W dS )a=
Handle interruptions to an interruptible system call.
Run an interruptible system call in a loop and retry if it raises EINTR.
The signal calls that may raise EINTR prior to Python 3.5 are listed in
PEP 0475. Any calls to these functions must be wrapped in eintr_retry_call
in order to handle EINTR returns in older versions of Python.
This function is safe to use under Python 3.5 and newer since the wrapped
function will simply return without raising EINTR.
This function is based on _eintr_retry_call in python's subprocess.py.
r N)�select�OSError�IOError�errorr �errno�argsZEINTR)�funcr. �kwargsr) �errZ
error_coder
r
r �eintr_retry_call� s
r2 c C s t tddg��} t| j� �S )ak
Get the version of the underlying udev library.
udev doesn't use a standard major-minor versioning scheme, but instead
labels releases with a single consecutive number. Consequently, the
version number returned by this function is a single integer, and not a
tuple (like for instance the interpreter version in
:data:`sys.version_info`).
As libudev itself does not provide a function to query the version number,
this function calls the ``udevadm`` utility, so be prepared to catch
:exc:`~exceptions.EnvironmentError` and
:exc:`~subprocess.CalledProcessError` if you call this function.
Return the version number as single integer. Raise
:exc:`~exceptions.ValueError`, if the version number retrieved from udev
could not be converted to an integer. Raise
:exc:`~exceptions.EnvironmentError`, if ``udevadm`` was not found, or could
not be executed. Raise :exc:`subprocess.CalledProcessError`, if
``udevadm`` returned a non-zero exit code. On Python 2.7 or newer, the
``output`` attribute of this exception is correctly set.
.. versionadded:: 0.8
Zudevadmz --version)r r r �strip)�outputr
r
r � udev_version� s r5 )�__doc__Z
__future__r r r r �
subprocessr � ImportErrorZpyudev._compatr! r
r" r- r r r r r r r( r2 r5 r
r
r
r �<module> s$
! __pycache__/discover.cpython-36.pyc 0000644 00000032356 15035142004 0013223 0 ustar 00 3
u1�W�, � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlZddlZddl Z ddl
Z
ddl m Z ddl m
Z
d d
� Ze
jej�G d d � d e��ZG d
d� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZdS )z�
pyudev.discover
===============
Tools to discover a device given limited information.
.. moduleauthor:: mulhern <amulhern@redhat.com>
� )�absolute_import)�division)�print_function)�unicode_literalsN)�Devices)�DeviceNotFoundErrorc s t j� �� fdd��}|S )z\
Allow Device discovery methods to return None instead of raising an
exception.
c s$ y
� | |�S t k
r dS X dS )z�
Returns result of calling ``func`` on ``args``, ``kwargs``.
Returns None if ``func`` raises :exc:`DeviceNotFoundError`.
N)r )�args�kwargs)�func� � /usr/lib/python3.6/discover.py�the_func1 s
z wrap_exception.<locals>.the_func)� functools�wraps)r
r
r )r
r �wrap_exception+ s r c @ sL e Zd ZdZeejdd� ��Zeejdd� ��Zedd� �Z edd � �Z
d
S ) �
HypothesiszM
Represents a hypothesis about the meaning of the device identifier.
c C s
t � �dS )a�
Match the given string according to the hypothesis.
The purpose of this method is to obtain a value corresponding to
``value`` if that is possible. It may use a regular expression, but
in general it should just return ``value`` and let the lookup method
sort out the rest.
:param str value: the string to inspect
:returns: the matched thing or None if unmatched
:rtype: the type of lookup's key parameter or NoneType
N)�NotImplementedError)�cls�valuer r r �matchD s zHypothesis.matchc C s
t � �dS )aN
Lookup the given string according to the hypothesis.
:param Context context: the pyudev context
:param key: a key with which to lookup the device
:type key: the type of match's return value if not None
:returns: a list of Devices obtained
:rtype: frozenset of :class:`Device`
N)r )r �context�keyr r r �lookupU s zHypothesis.lookupc C s dS )z�
A potentially expensive method that may allow an :class:`Hypothesis`
to find devices more rapidly or to find a device that it would
otherwise miss.
:param Context context: the pyudev context
Nr )r r r r r �setupc s zHypothesis.setupc C s$ | j |�}|dk r | j||�S t� S )a
Get any devices that may correspond to the given string.
:param Context context: the pyudev context
:param str value: the value to look for
:returns: a list of devices obtained
:rtype: set of :class:`Device`
N)r r � frozenset)r r r r r r r � get_devicesn s
zHypothesis.get_devicesN) �__name__�
__module__� __qualname__�__doc__� classmethod�abc�abstractmethodr r r r r r r r r > s
r c @ sL e Zd ZdZedd� �Zedd� �Zedd� �Zedd � �Zed
d � �Z d S )
�DeviceNumberHypothesisz�
Represents the hypothesis that the device is a device number.
The device may be separated into major/minor number or a composite number.
c C s8 t jd�}|j|�}|o6tjt|jd��t|jd���S )z�
Match the number under the assumption that it is a major,minor pair.
:param str value: value to match
:returns: the device number or None
:rtype: int or NoneType
z#^(?P<major>\d+)(\D+)(?P<minor>\d+)$�major�minor)�re�compiler �os�makedev�int�group)r r Zmajor_minor_rer r r r �_match_major_minor� s
z)DeviceNumberHypothesis._match_major_minorc C s& t jd�}|j|�}|o$t|jd��S )z�
Match the number under the assumption that it is a single number.
:param str value: value to match
:returns: the device number or None
:rtype: int or NoneType
z^(?P<number>\d+)$Znumber)r& r' r r* r+ )r r Z number_rer r r r �
_match_number� s
z$DeviceNumberHypothesis._match_numberc C s | j |�p| j|�S )z�
Match the number under the assumption that it is a device number.
:returns: the device number or None
:rtype: int or NoneType
)r, r- )r r r r r r � s z DeviceNumberHypothesis.matchc C s |j }tjtjj|d��S )z�
Find subsystems in /sys/dev.
:param Context context: the context
:returns: a lis of available subsystems
:rtype: list of str
Zdev)�sys_pathr( �listdir�path�join)r r r. r r r �find_subsystems� s z&DeviceNumberHypothesis.find_subsystemsc s8 t tj��� ��fdd�| j� �D �}tdd� |D ��S )z�
Lookup by the device number.
:param Context context: the context
:param int key: the device number
:returns: a list of matching devices
:rtype: frozenset of :class:`Device`
c 3 s | ]}�� |��V qd S )Nr )�.0�s)r r
r r r � <genexpr>� s z0DeviceNumberHypothesis.lookup.<locals>.<genexpr>c s s | ]}|d k r|V qd S )Nr )r3 �rr r r r5 � s )r r Zfrom_device_numberr2 r )r r r �resr )r r
r r r � s
z DeviceNumberHypothesis.lookupN)
r r r r r r, r- r r2 r r r r r r# | s
r# c @ s( e Zd ZdZedd� �Zedd� �ZdS )�DevicePathHypothesiszG
Discover the device assuming the identifier is a device path.
c C s |S )z�
Match ``value`` under the assumption that it is a device path.
:returns: the device path or None
:rtype: str or NoneType
r )r r r r r r � s zDevicePathHypothesis.matchc C s( t tj�||�}|dk r"t|f�S t� S )z�
Lookup by the path.
:param Context context: the context
:param str key: the device path
:returns: a list of matching devices
:rtype: frozenset of :class:`Device`
N)r r Z from_pathr )r r r r7 r r r r � s
zDevicePathHypothesis.lookupN)r r r r r r r r r r r r8 � s
r8 c @ s4 e Zd ZdZedd� �Zedd� �Zedd� �ZdS ) �DeviceNameHypothesiszf
Discover the device assuming the input is a device name.
Try every available subsystem.
c s< |j � d}� fdd�|D �}dd� |D �}tdd� |D ��S ) z�
Find all subsystems in sysfs.
:param Context context: the context
:rtype: frozenset
:returns: subsystems in sysfs
�bus�class� subsystemc 3 s | ]}t jj� |�V qd S )N)r( r0 r1 )r3 �name)r. r r r5 � s z7DeviceNameHypothesis.find_subsystems.<locals>.<genexpr>c s s | ]}t jj|�r|V qd S )N)r( r0 �isdir)r3 �dr r r r5 � s c s s" | ]}t j|�D ]
}|V qqd S )N)r( r/ )r3 r? �nr r r r5 � s )r: r; r< )r. r )r r ZdirnamesZabsnamesZ realnamesr )r. r r2 � s
z$DeviceNameHypothesis.find_subsystemsc C s |S )z�
Match ``value`` under the assumption that it is a device name.
:returns: the device path or None
:rtype: str or NoneType
r )r r r r r r � s zDeviceNameHypothesis.matchc s8 t tj��� ��fdd�| j� �D �}tdd� |D ��S )z�
Lookup by the path.
:param Context context: the context
:param str key: the device path
:returns: a list of matching devices
:rtype: frozenset of :class:`Device`
c 3 s | ]}�� |��V qd S )Nr )r3 r4 )r r
r r r r5 s z.DeviceNameHypothesis.lookup.<locals>.<genexpr>c s s | ]}|d k r|V qd S )Nr )r3 r6 r r r r5 s )r r � from_namer2 r )r r r r7 r )r r
r r r s
zDeviceNameHypothesis.lookupN)r r r r r r2 r r r r r r r9 � s
r9 c @ sZ e Zd ZdZdddddddd d
d d g Zed
d� �Zedd� �Zedd� �Zedd� �Z dS )�DeviceFileHypothesisz�
Discover the device assuming the value is some portion of a device file.
The device file may be a link to a device node.
z/devz/dev/disk/by-idz/dev/disk/by-labelz/dev/disk/by-partlabelz/dev/disk/by-partuuidz/dev/disk/by-pathz/dev/disk/by-uuidz/dev/input/by-pathz /dev/mapperz/dev/mdz/dev/vgc C s: |j � }dd� |D �}dd� |D �}ttdd� |D ���S )a7
Get all directories that may contain links to device nodes.
This method checks the device links of every device, so it is very
expensive.
:param Context context: the context
:returns: a sorted list of directories that contain device links
:rtype: list
c s s | ]}t |j�r|V qd S )N)�list� device_links)r3 r? r r r r5 5 s z5DeviceFileHypothesis.get_link_dirs.<locals>.<genexpr>c s s | ]}|j D ]
}|V q qd S )N)rD )r3 r? �lr r r r5 6 s c s s | ]}t jj|�V qd S )N)r( r0 �dirname)r3 rE r r r r5 7 s )Z list_devices�sorted�set)r r �devicesZdevices_with_linksZlinksr r r �
get_link_dirs( s z"DeviceFileHypothesis.get_link_dirsc C s | j |�| _dS )z�
Set the link directories to be used when discovering by file.
Uses `get_link_dirs`, so is as expensive as it is.
:param Context context: the context
N)rJ �
_LINK_DIRS)r r r r r r 9 s zDeviceFileHypothesis.setupc C s |S )Nr )r r r r r r D s zDeviceFileHypothesis.matchc sr t tj��d�kr4�� ��}|dk r.t|f�S t� S �fdd�| jD �}� �fdd�|D �}tdd� |D ��S dS )a�
Lookup the device under the assumption that the key is part of
the name of a device file.
:param Context context: the context
:param str key: a portion of the device file name
It is assumed that either it is the whole name of the device file
or it is the basename.
A device file may be a device node or a device link.
�/Nc 3 s | ]}t jj|� �V qd S )N)r( r0 r1 )r3 Zld)r r r r5 [ s z.DeviceFileHypothesis.lookup.<locals>.<genexpr>c 3 s | ]}�� |�V qd S )Nr )r3 �f)r r
r r r5 \ s c s s | ]}|d k r|V qd S )Nr )r3 r? r r r r5 ] s )r r Zfrom_device_filer rK )r r r Zdevice�filesrI r )r r
r r r H s
zDeviceFileHypothesis.lookupN)
r r r r rK r rJ r r r r r r r rB s rB c @ s4 e Zd ZdZeeeegZdd� Z dd� Z
dd� Z dS ) � Discoveryz1
Provides discovery methods for devices.
c C s | j | _d S )N)� _HYPOTHESES� _hypotheses)�selfr r r �__init__m s zDiscovery.__init__c C s x| j D ]}|j|� qW dS )z
Set up individual hypotheses.
May be an expensive call.
:param Context context: the context
N)rQ r )rR r Zhypr r r r p s zDiscovery.setupc s t � �fdd�| jD ��S )z�
Get the devices corresponding to value.
:param Context context: the context
:param str value: some identifier of the device
:returns: a list of corresponding devices
:rtype: frozenset of :class:`Device`
c 3 s$ | ] }|j � ��D ]
}|V qqd S )N)r )r3 �hr? )r r r r r5 � s z(Discovery.get_devices.<locals>.<genexpr>)r rQ )rR r r r )r r r r { s zDiscovery.get_devicesN) r r r r rB r9 r# r8 rP rS r r r r r r rO ` s rO )r Z
__future__r r r r r! r r( r& ZsixZ
pyudev.devicer r r Z
add_metaclass�ABCMeta�objectr r# r8 r9 rB rO r r r r �<module> s& =K /M __pycache__/core.cpython-36.pyc 0000644 00000031216 15035142004 0012327 0 ustar 00 3
u1�Ws4 � @ s� d Z ddlmZmZmZmZ ddlmZ ddlm Z ddl
m Z ddl
m Z ddl
mZ ddlmZ dd lmZ dd
lmZ dd lmZ G d d
� d
e�ZG dd� de�ZdS )z�
pyudev.core
===========
Core types and functions of :mod:`pyudev`.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�print_function�division�unicode_literals�absolute_import)�Devices)�DeviceNotFoundAtPathError)�ERROR_CHECKERS)�
SIGNATURES)�load_ctypes_library)�ensure_byte_string)�ensure_unicode_string)�property_value_to_bytes)�udev_list_iteratec @ sf e Zd ZdZdd� Zdd� Zedd� �Zedd � �Zed
d � �Z ed d
� �Z
e
j dd
� �Z
dd� Z dS )�Contexta
A device database connection.
This class represents a connection to the udev device database, and is
really *the* central object to access udev. You need an instance of this
class for almost anything else in pyudev.
This class itself gives access to various udev configuration data (e.g.
:attr:`sys_path`, :attr:`device_path`), and provides device enumeration
(:meth:`list_devices()`).
Instances of this class can directly be given as ``udev *`` to functions
wrapped through :mod:`ctypes`.
c C s t dtt�| _| jj� | _dS )z'
Create a new context.
ZudevN)r
r r �_libudevZudev_new�_as_parameter_)�self� r �/usr/lib/python3.6/core.py�__init__< s zContext.__init__c C s | j j| � d S )N)r Z
udev_unref)r r r r �__del__C s zContext.__del__c C s$ t | jd�r t| jj| ��S dS dS )zV
The ``sysfs`` mount point defaulting to ``/sys'`` as unicode string.
�udev_get_sys_pathz/sysN)�hasattrr r r )r r r r �sys_pathF s zContext.sys_pathc C s$ t | jd�r t| jj| ��S dS dS )zU
The device directory path defaulting to ``/dev`` as unicode string.
�udev_get_dev_pathz/devN)r r r r )r r r r � device_pathQ s zContext.device_pathc C s$ t | jd�r t| jj| ��S dS dS )z�
The run runtime directory path defaulting to ``/run`` as unicode
string.
.. udevversion:: 167
.. versionadded:: 0.10
�udev_get_run_pathz /run/udevN)r r r r )r r r r �run_path\ s
zContext.run_pathc C s | j j| �S )a
The logging priority of the interal logging facitility of udev as
integer with a standard :mod:`syslog` priority. Assign to this
property to change the logging priority.
UDev uses the standard :mod:`syslog` priorities. Constants for these
priorities are defined in the :mod:`syslog` module in the standard
library:
>>> import syslog
>>> context = pyudev.Context()
>>> context.log_priority = syslog.LOG_DEBUG
.. versionadded:: 0.9
)r Zudev_get_log_priority)r r r r � log_priorityk s zContext.log_priorityc C s | j j| |� dS )zT
Set the log priority.
:param int value: the log priority.
N)r Zudev_set_log_priority)r �valuer r r r ~ s c K s t | �jf |�S )a"
List all available devices.
The arguments of this method are the same as for
:meth:`Enumerator.match()`. In fact, the arguments are simply passed
straight to method :meth:`~Enumerator.match()`.
This function creates and returns an :class:`Enumerator` object,
that can be used to filter the list of devices, and eventually
retrieve :class:`Device` objects representing matching devices.
.. versionchanged:: 0.8
Accept keyword arguments now for easy matching.
)�
Enumerator�match)r �kwargsr r r � list_devices� s zContext.list_devicesN)
�__name__�
__module__� __qualname__�__doc__r r �propertyr r r r �setterr# r r r r r , s r c @ sl e Zd ZdZdd� Zdd� Zdd� Zdd d
�Zd d � Zd
d� Z ddd�Z
dd� Z dd� Z dd� Z
dd� ZdS ) r a�
A filtered iterable of devices.
To retrieve devices, simply iterate over an instance of this class.
This operation yields :class:`Device` objects representing the available
devices.
Before iteration the device list can be filtered by subsystem or by
property values using :meth:`match_subsystem` and
:meth:`match_property`. Multiple subsystem (property) filters are
combined using a logical OR, filters of different types are combined
using a logical AND. The following filter for instance::
devices.match_subsystem('block').match_property(
'ID_TYPE', 'disk').match_property('DEVTYPE', 'disk')
means the following::
subsystem == 'block' and (ID_TYPE == 'disk' or DEVTYPE == 'disk')
Once added, a filter cannot be removed anymore. Create a new object
instead.
Instances of this class can directly be given as given ``udev_enumerate *``
to functions wrapped through :mod:`ctypes`.
c C s2 t |t�std��|| _|jj|�| _|j| _dS )z�
Create a new enumerator with the given ``context`` (a
:class:`Context` instance).
While you can create objects of this class directly, this is not
recommended. Call :method:`Context.list_devices()` instead.
zInvalid context objectN)�
isinstancer � TypeError�contextr Zudev_enumerate_newr )r r, r r r r � s
zEnumerator.__init__c C s | j j| � d S )N)r Zudev_enumerate_unref)r r r r r � s zEnumerator.__del__c K s� |j dd�}|dk r | j|� |j dd�}|dk r<| j|� |j dd�}|dk rZ| j|� |j dd�}|dk rx| j|� x |j� D ]\}}| j||� q�W | S )a2
Include devices according to the rules defined by the keyword
arguments. These keyword arguments are interpreted as follows:
- The value for the keyword argument ``subsystem`` is forwarded to
:meth:`match_subsystem()`.
- The value for the keyword argument ``sys_name`` is forwared to
:meth:`match_sys_name()`.
- The value for the keyword argument ``tag`` is forwared to
:meth:`match_tag()`.
- The value for the keyword argument ``parent`` is forwared to
:meth:`match_parent()`.
- All other keyword arguments are forwareded one by one to
:meth:`match_property()`. The keyword argument itself is interpreted
as property name, the value of the keyword argument as the property
value.
All keyword arguments are optional, calling this method without no
arguments at all is simply a noop.
Return the instance again.
.. versionadded:: 0.8
.. versionchanged:: 0.13
Add ``parent`` keyword.
� subsystemN�sys_name�tag�parent)�pop�match_subsystem�match_sys_name� match_tag� match_parent�items�match_property)r r" r- r. r/ r0 �propr r r r r! � s
zEnumerator.matchFc C s& |r | j jn| j j}|| t|�� | S )a$
Include all devices, which are part of the given ``subsystem``.
``subsystem`` is either a unicode string or a byte string, containing
the name of the subsystem. If ``nomatch`` is ``True`` (default is
``False``), the match is inverted: A device is only included if it is
*not* part of the given ``subsystem``.
Note that, if a device has no subsystem, it is not included either
with value of ``nomatch`` True or with value of ``nomatch`` False.
Return the instance again.
)r Z$udev_enumerate_add_nomatch_subsystemZ"udev_enumerate_add_match_subsystemr )r r- �nomatchr! r r r r2 � s zEnumerator.match_subsystemc C s | j j| t|�� | S )z�
Include all devices with the given name.
``sys_name`` is a byte or unicode string containing the device name.
Return the instance again.
.. versionadded:: 0.8
)r Z udev_enumerate_add_match_sysnamer )r r. r r r r3 s
zEnumerator.match_sys_namec C s | j j| t|�t|�� | S )a�
Include all devices, whose ``prop`` has the given ``value``.
``prop`` is either a unicode string or a byte string, containing
the name of the property to match. ``value`` is a property value,
being one of the following types:
- :func:`int`
- :func:`bool`
- A byte string
- Anything convertable to a unicode string (including a unicode string
itself)
Return the instance again.
)r Z!udev_enumerate_add_match_propertyr r
)r r8 r r r r r7 s zEnumerator.match_propertyc C s, |s | j jn| j j}|| t|�t|�� | S )a�
Include all devices, whose ``attribute`` has the given ``value``.
``attribute`` is either a unicode string or a byte string, containing
the name of a sys attribute to match. ``value`` is an attribute value,
being one of the following types:
- :func:`int`,
- :func:`bool`
- A byte string
- Anything convertable to a unicode string (including a unicode string
itself)
If ``nomatch`` is ``True`` (default is ``False``), the match is
inverted: A device is include if the ``attribute`` does *not* match
the given ``value``.
.. note::
If ``nomatch`` is ``True``, devices which do not have the given
``attribute`` at all are also included. In other words, with
``nomatch=True`` the given ``attribute`` is *not* guaranteed to
exist on all returned devices.
Return the instance again.
)r Z udev_enumerate_add_match_sysattrZ"udev_enumerate_add_nomatch_sysattrr r
)r Z attributer r9 r! r r r �match_attribute' s
zEnumerator.match_attributec C s | j j| t|�� | S )z�
Include all devices, which have the given ``tag`` attached.
``tag`` is a byte or unicode string containing the tag name.
Return the instance again.
.. udevversion:: 154
.. versionadded:: 0.6
)r Z udev_enumerate_add_match_tagr )r r/ r r r r4 I s zEnumerator.match_tagc C s | j j| � | S )a�
Include only devices, which are initialized.
Initialized devices have properly set device node permissions and
context, and are (in case of network devices) fully renamed.
Currently this will not affect devices which do not have device nodes
and are not network interfaces.
Return the instance again.
.. seealso:: :attr:`Device.is_initialized`
.. udevversion:: 165
.. versionadded:: 0.8
)r Z'udev_enumerate_add_match_is_initialized)r r r r �match_is_initializedX s z Enumerator.match_is_initializedc C s | j j| |� | S )a
Include all devices on the subtree of the given ``parent`` device.
The ``parent`` device itself is also included.
``parent`` is a :class:`~pyudev.Device`.
Return the instance again.
.. udevversion:: 172
.. versionadded:: 0.13
)r Z udev_enumerate_add_match_parent)r r0 r r r r5 m s zEnumerator.match_parentc c sb | j j| � | j j| �}xDt| j |�D ]4\}}ytj| j|�V W q& tk
rX w&Y q&X q&W dS )z\
Iterate over all matching devices.
Yield :class:`Device` objects.
N)r Zudev_enumerate_scan_devicesZ udev_enumerate_get_list_entryr r Z
from_sys_pathr, r )r �entry�name�_r r r �__iter__~ s zEnumerator.__iter__N)F)F)r$ r% r& r' r r r! r2 r3 r7 r: r4 r; r5 r? r r r r r � s ,
"r N)r' Z
__future__r r r r Z
pyudev.devicer Zpyudev.device._errorsr Zpyudev._ctypeslib.libudevr r Zpyudev._ctypeslib.utilsr
Z pyudev._utilr r r
r �objectr r r r r r �<module> s m __pycache__/version.cpython-36.pyc 0000644 00000001143 15035142004 0013060 0 ustar 00 3
u1�WM � @ sH d Z d Zddjdd� edd � D ��djd
d� ed d� D ��f ZdS ) zx
pyudev.version
==============
Version information.
.. moduleauthor:: mulhern <amulhern@redhat.com>
� � � z%s%s�.c c s | ]}t |�V qd S )N)�str)�.0�x� r � /usr/lib/python3.6/version.py� <genexpr> s r
N� c c s | ]}t |�V qd S )N)r )r r r r r r
s )r r r r )�__doc__Z__version_info__�join� __version__r r r r �<module> s __pycache__/discover.cpython-36.opt-1.pyc 0000644 00000032356 15035142004 0014162 0 ustar 00 3
u1�W�, � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlZddlZddl Z ddl
Z
ddl m Z ddl m
Z
d d
� Ze
jej�G d d � d e��ZG d
d� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZdS )z�
pyudev.discover
===============
Tools to discover a device given limited information.
.. moduleauthor:: mulhern <amulhern@redhat.com>
� )�absolute_import)�division)�print_function)�unicode_literalsN)�Devices)�DeviceNotFoundErrorc s t j� �� fdd��}|S )z\
Allow Device discovery methods to return None instead of raising an
exception.
c s$ y
� | |�S t k
r dS X dS )z�
Returns result of calling ``func`` on ``args``, ``kwargs``.
Returns None if ``func`` raises :exc:`DeviceNotFoundError`.
N)r )�args�kwargs)�func� � /usr/lib/python3.6/discover.py�the_func1 s
z wrap_exception.<locals>.the_func)� functools�wraps)r
r
r )r
r �wrap_exception+ s r c @ sL e Zd ZdZeejdd� ��Zeejdd� ��Zedd� �Z edd � �Z
d
S ) �
HypothesiszM
Represents a hypothesis about the meaning of the device identifier.
c C s
t � �dS )a�
Match the given string according to the hypothesis.
The purpose of this method is to obtain a value corresponding to
``value`` if that is possible. It may use a regular expression, but
in general it should just return ``value`` and let the lookup method
sort out the rest.
:param str value: the string to inspect
:returns: the matched thing or None if unmatched
:rtype: the type of lookup's key parameter or NoneType
N)�NotImplementedError)�cls�valuer r r �matchD s zHypothesis.matchc C s
t � �dS )aN
Lookup the given string according to the hypothesis.
:param Context context: the pyudev context
:param key: a key with which to lookup the device
:type key: the type of match's return value if not None
:returns: a list of Devices obtained
:rtype: frozenset of :class:`Device`
N)r )r �context�keyr r r �lookupU s zHypothesis.lookupc C s dS )z�
A potentially expensive method that may allow an :class:`Hypothesis`
to find devices more rapidly or to find a device that it would
otherwise miss.
:param Context context: the pyudev context
Nr )r r r r r �setupc s zHypothesis.setupc C s$ | j |�}|dk r | j||�S t� S )a
Get any devices that may correspond to the given string.
:param Context context: the pyudev context
:param str value: the value to look for
:returns: a list of devices obtained
:rtype: set of :class:`Device`
N)r r � frozenset)r r r r r r r � get_devicesn s
zHypothesis.get_devicesN) �__name__�
__module__� __qualname__�__doc__� classmethod�abc�abstractmethodr r r r r r r r r > s
r c @ sL e Zd ZdZedd� �Zedd� �Zedd� �Zedd � �Zed
d � �Z d S )
�DeviceNumberHypothesisz�
Represents the hypothesis that the device is a device number.
The device may be separated into major/minor number or a composite number.
c C s8 t jd�}|j|�}|o6tjt|jd��t|jd���S )z�
Match the number under the assumption that it is a major,minor pair.
:param str value: value to match
:returns: the device number or None
:rtype: int or NoneType
z#^(?P<major>\d+)(\D+)(?P<minor>\d+)$�major�minor)�re�compiler �os�makedev�int�group)r r Zmajor_minor_rer r r r �_match_major_minor� s
z)DeviceNumberHypothesis._match_major_minorc C s& t jd�}|j|�}|o$t|jd��S )z�
Match the number under the assumption that it is a single number.
:param str value: value to match
:returns: the device number or None
:rtype: int or NoneType
z^(?P<number>\d+)$Znumber)r& r' r r* r+ )r r Z number_rer r r r �
_match_number� s
z$DeviceNumberHypothesis._match_numberc C s | j |�p| j|�S )z�
Match the number under the assumption that it is a device number.
:returns: the device number or None
:rtype: int or NoneType
)r, r- )r r r r r r � s z DeviceNumberHypothesis.matchc C s |j }tjtjj|d��S )z�
Find subsystems in /sys/dev.
:param Context context: the context
:returns: a lis of available subsystems
:rtype: list of str
Zdev)�sys_pathr( �listdir�path�join)r r r. r r r �find_subsystems� s z&DeviceNumberHypothesis.find_subsystemsc s8 t tj��� ��fdd�| j� �D �}tdd� |D ��S )z�
Lookup by the device number.
:param Context context: the context
:param int key: the device number
:returns: a list of matching devices
:rtype: frozenset of :class:`Device`
c 3 s | ]}�� |��V qd S )Nr )�.0�s)r r
r r r � <genexpr>� s z0DeviceNumberHypothesis.lookup.<locals>.<genexpr>c s s | ]}|d k r|V qd S )Nr )r3 �rr r r r5 � s )r r Zfrom_device_numberr2 r )r r r �resr )r r
r r r � s
z DeviceNumberHypothesis.lookupN)
r r r r r r, r- r r2 r r r r r r# | s
r# c @ s( e Zd ZdZedd� �Zedd� �ZdS )�DevicePathHypothesiszG
Discover the device assuming the identifier is a device path.
c C s |S )z�
Match ``value`` under the assumption that it is a device path.
:returns: the device path or None
:rtype: str or NoneType
r )r r r r r r � s zDevicePathHypothesis.matchc C s( t tj�||�}|dk r"t|f�S t� S )z�
Lookup by the path.
:param Context context: the context
:param str key: the device path
:returns: a list of matching devices
:rtype: frozenset of :class:`Device`
N)r r Z from_pathr )r r r r7 r r r r � s
zDevicePathHypothesis.lookupN)r r r r r r r r r r r r8 � s
r8 c @ s4 e Zd ZdZedd� �Zedd� �Zedd� �ZdS ) �DeviceNameHypothesiszf
Discover the device assuming the input is a device name.
Try every available subsystem.
c s< |j � d}� fdd�|D �}dd� |D �}tdd� |D ��S ) z�
Find all subsystems in sysfs.
:param Context context: the context
:rtype: frozenset
:returns: subsystems in sysfs
�bus�class� subsystemc 3 s | ]}t jj� |�V qd S )N)r( r0 r1 )r3 �name)r. r r r5 � s z7DeviceNameHypothesis.find_subsystems.<locals>.<genexpr>c s s | ]}t jj|�r|V qd S )N)r( r0 �isdir)r3 �dr r r r5 � s c s s" | ]}t j|�D ]
}|V qqd S )N)r( r/ )r3 r? �nr r r r5 � s )r: r; r< )r. r )r r ZdirnamesZabsnamesZ realnamesr )r. r r2 � s
z$DeviceNameHypothesis.find_subsystemsc C s |S )z�
Match ``value`` under the assumption that it is a device name.
:returns: the device path or None
:rtype: str or NoneType
r )r r r r r r � s zDeviceNameHypothesis.matchc s8 t tj��� ��fdd�| j� �D �}tdd� |D ��S )z�
Lookup by the path.
:param Context context: the context
:param str key: the device path
:returns: a list of matching devices
:rtype: frozenset of :class:`Device`
c 3 s | ]}�� |��V qd S )Nr )r3 r4 )r r
r r r r5 s z.DeviceNameHypothesis.lookup.<locals>.<genexpr>c s s | ]}|d k r|V qd S )Nr )r3 r6 r r r r5 s )r r � from_namer2 r )r r r r7 r )r r
r r r s
zDeviceNameHypothesis.lookupN)r r r r r r2 r r r r r r r9 � s
r9 c @ sZ e Zd ZdZdddddddd d
d d g Zed
d� �Zedd� �Zedd� �Zedd� �Z dS )�DeviceFileHypothesisz�
Discover the device assuming the value is some portion of a device file.
The device file may be a link to a device node.
z/devz/dev/disk/by-idz/dev/disk/by-labelz/dev/disk/by-partlabelz/dev/disk/by-partuuidz/dev/disk/by-pathz/dev/disk/by-uuidz/dev/input/by-pathz /dev/mapperz/dev/mdz/dev/vgc C s: |j � }dd� |D �}dd� |D �}ttdd� |D ���S )a7
Get all directories that may contain links to device nodes.
This method checks the device links of every device, so it is very
expensive.
:param Context context: the context
:returns: a sorted list of directories that contain device links
:rtype: list
c s s | ]}t |j�r|V qd S )N)�list� device_links)r3 r? r r r r5 5 s z5DeviceFileHypothesis.get_link_dirs.<locals>.<genexpr>c s s | ]}|j D ]
}|V q qd S )N)rD )r3 r? �lr r r r5 6 s c s s | ]}t jj|�V qd S )N)r( r0 �dirname)r3 rE r r r r5 7 s )Z list_devices�sorted�set)r r �devicesZdevices_with_linksZlinksr r r �
get_link_dirs( s z"DeviceFileHypothesis.get_link_dirsc C s | j |�| _dS )z�
Set the link directories to be used when discovering by file.
Uses `get_link_dirs`, so is as expensive as it is.
:param Context context: the context
N)rJ �
_LINK_DIRS)r r r r r r 9 s zDeviceFileHypothesis.setupc C s |S )Nr )r r r r r r D s zDeviceFileHypothesis.matchc sr t tj��d�kr4�� ��}|dk r.t|f�S t� S �fdd�| jD �}� �fdd�|D �}tdd� |D ��S dS )a�
Lookup the device under the assumption that the key is part of
the name of a device file.
:param Context context: the context
:param str key: a portion of the device file name
It is assumed that either it is the whole name of the device file
or it is the basename.
A device file may be a device node or a device link.
�/Nc 3 s | ]}t jj|� �V qd S )N)r( r0 r1 )r3 Zld)r r r r5 [ s z.DeviceFileHypothesis.lookup.<locals>.<genexpr>c 3 s | ]}�� |�V qd S )Nr )r3 �f)r r
r r r5 \ s c s s | ]}|d k r|V qd S )Nr )r3 r? r r r r5 ] s )r r Zfrom_device_filer rK )r r r Zdevice�filesrI r )r r
r r r H s
zDeviceFileHypothesis.lookupN)
r r r r rK r rJ r r r r r r r rB s rB c @ s4 e Zd ZdZeeeegZdd� Z dd� Z
dd� Z dS ) � Discoveryz1
Provides discovery methods for devices.
c C s | j | _d S )N)� _HYPOTHESES� _hypotheses)�selfr r r �__init__m s zDiscovery.__init__c C s x| j D ]}|j|� qW dS )z
Set up individual hypotheses.
May be an expensive call.
:param Context context: the context
N)rQ r )rR r Zhypr r r r p s zDiscovery.setupc s t � �fdd�| jD ��S )z�
Get the devices corresponding to value.
:param Context context: the context
:param str value: some identifier of the device
:returns: a list of corresponding devices
:rtype: frozenset of :class:`Device`
c 3 s$ | ] }|j � ��D ]
}|V qqd S )N)r )r3 �hr? )r r r r r5 � s z(Discovery.get_devices.<locals>.<genexpr>)r rQ )rR r r r )r r r r { s zDiscovery.get_devicesN) r r r r rB r9 r# r8 rP rS r r r r r r rO ` s rO )r Z
__future__r r r r r! r r( r& ZsixZ
pyudev.devicer r r Z
add_metaclass�ABCMeta�objectr r# r8 r9 rB rO r r r r �<module> s& =K /M __pycache__/_qt_base.cpython-36.pyc 0000644 00000014331 15035142004 0013153 0 ustar 00 3
u1�Wk � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlmZ G dd � d e �Z
G d
d � d e
�Z d d
� Z G dd� de �Z
G dd� de �ZdS )z�
pyudev._qt_base
===============
Base mixin class for Qt4,Qt5 support.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literalsN)�Devicec @ sB e Zd ZdZdd� Zedd� �Zejdd� �Zdd� Zd d
� Z d S ) �MonitorObserverMixinz0
Base mixin for pyqt monitor observers.
c C s2 || _ ||j� |j| �| _| jjt j| j� d S )N)�monitor�filenoZRead�notifierZ activated�intZconnect�_process_udev_event)�selfr �notifier_class� r � /usr/lib/python3.6/_qt_base.py�_setup_notifier+ s z$MonitorObserverMixin._setup_notifierc C s
| j j� S )aY
Whether this observer is enabled or not.
If ``True`` (the default), this observer is enabled, and emits events.
Otherwise it is disabled and does not emit any events. This merely
reflects the state of the ``enabled`` property of the underlying
:attr:`notifier`.
.. versionadded:: 0.14
)r
Z isEnabled)r
r r r �enabled1 s z MonitorObserverMixin.enabledc C s | j j|� d S )N)r
Z
setEnabled)r
�valuer r r r ? s c C s$ | j jdd�}|dk r | j|� dS )z�
Attempt to receive a single device event from the monitor, process
the event and emit corresponding signals.
Called by ``QSocketNotifier``, if data is available on the udev
monitoring socket.
r )ZtimeoutN)r Zpoll� _emit_event)r
�devicer r r r C s z(MonitorObserverMixin._process_udev_eventc C s | j j|� d S )N)� deviceEvent�emit)r
r r r r r O s z MonitorObserverMixin._emit_eventN)
�__name__�
__module__� __qualname__�__doc__r �propertyr �setterr r r r r r r % s r c @ s e Zd ZdZdd� Zdd� ZdS )�QUDevMonitorObserverMixinz*
Obsolete monitor observer mixin.
c C s> t j| ||� | j| j| j| jd�| _dd l}|jdt � d S )N)�add�removeZchangeZmover zAWill be removed in 1.0. Use pyudev.pyqt4.MonitorObserver instead.)
r r � deviceAdded�
deviceRemoved�
deviceChanged� deviceMoved�_action_signal_map�warnings�warn�DeprecationWarning)r
r r r& r r r r Y s z)QUDevMonitorObserverMixin._setup_notifierc C s4 | j j|j|� | jj|j�}|d k r0|j|� d S )N)r r �actionr% �get)r
r �signalr r r r d s z%QUDevMonitorObserverMixin._emit_eventN)r r r r r r r r r r r S s r c s d� �fdd� }|S )a
Generates an initializer to observer the given ``monitor``
(a :class:`~pyudev.Monitor`):
``parent`` is the parent :class:`~PyQt{4,5}.QtCore.QObject` of this
object. It is passed unchanged to the inherited constructor of
:class:`~PyQt{4,5}.QtCore.QObject`.
Nc s � j | |� | j|�� d S )N)�__init__r )r
r �parent)�qobject�socket_notifierr r r, t s zmake_init.<locals>.__init__)Nr )r. r/ r, r )r. r/ r � make_initj s
r0 c @ s e Zd ZdZedd� �ZdS )�MonitorObserverGeneratorz4
Class to generate a MonitorObserver class.
c C s. t td�| tftd�t| |�td�|t�i�S )a Generates an observer for device events integrating into the
PyQt{4,5} mainloop.
This class inherits :class:`~PyQt{4,5}.QtCore.QObject` to turn device
events into Qt signals:
>>> from pyudev import Context, Monitor
>>> from pyudev.pyqt4 import MonitorObserver
>>> context = Context()
>>> monitor = Monitor.from_netlink(context)
>>> monitor.filter_by(subsystem='input')
>>> observer = MonitorObserver(monitor)
>>> def device_event(device):
... print('event {0} on device {1}'.format(device.action, device))
>>> observer.deviceEvent.connect(device_event)
>>> monitor.start()
This class is a child of :class:`~{PySide, PyQt{4,5}}.QtCore.QObject`.
ZMonitorObserverr, r )�type�strr r0 r )r. r+ r/ r r r �make_monitor_observer� s
z.MonitorObserverGenerator.make_monitor_observerN)r r r r � staticmethodr4 r r r r r1 | s r1 c @ s e Zd ZdZedd� �ZdS )� QUDevMonitorObserverGeneratorz4
Class to generate a MonitorObserver class.
c C sb t td�| tftd�t| |�td�|tjt�td�|t�td�|t�td�|t�td�|t�i�S )a Generates an observer for device events integrating into the
PyQt{4,5} mainloop.
This class inherits :class:`~PyQt{4,5}.QtCore.QObject` to turn device
events into Qt signals:
>>> from pyudev import Context, Monitor
>>> from pyudev.pyqt4 import MonitorObserver
>>> context = Context()
>>> monitor = Monitor.from_netlink(context)
>>> monitor.filter_by(subsystem='input')
>>> observer = MonitorObserver(monitor)
>>> def device_event(device):
... print('event {0} on device {1}'.format(device.action, device))
>>> observer.deviceEvent.connect(device_event)
>>> monitor.start()
This class is a child of :class:`~{PyQt{4,5}, PySide}.QtCore.QObject`.
ZQUDevMonitorObserverr, r r! r" r# r$ )r2 r3 r r0 �sixZ text_typer )r. r+ r/ r r r r4 � s z3QUDevMonitorObserverGenerator.make_monitor_observerN)r r r r r5 r4 r r r r r6 � s r6 )r Z
__future__r r r r r7 Z
pyudev.devicer �objectr r r0 r1 r6 r r r r �<module> s .' __pycache__/monitor.cpython-36.pyc 0000644 00000046361 15035142004 0013075 0 ustar 00 3
u1�W�Q � @ s� d Z ddlmZmZmZmZ ddlZddlZddlm Z ddl
m Z ddl m
Z
ddlmZ ddlmZ dd lmZ dd
lmZ G d d � d e�ZG d
d� de �ZdS )z�
pyudev.monitor
==============
Monitor implementation.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�print_function�division�unicode_literals�absolute_importN)�Thread)�partial)�Device)�eintr_retry_call)�ensure_byte_string)�pipe)�pollc @ s� e Zd ZdZdd� Zdd� Zed"dd��Zed d
� �Z d d � Z
d#dd�Z dd� Z dd� Z
dd� Zdd� Zdd� Zdd� Zd$d d �Zd d � Zd d!� Zd
S )%�Monitorat
A synchronous device event monitor.
A :class:`Monitor` objects connects to the udev daemon and listens for
changes to the device list. A monitor is created by connecting to the
kernel daemon through netlink (see :meth:`from_netlink`):
>>> from pyudev import Context, Monitor
>>> context = Context()
>>> monitor = Monitor.from_netlink(context)
Once the monitor is created, you can add a filter using :meth:`filter_by()`
or :meth:`filter_by_tag()` to drop incoming events in subsystems, which are
not of interest to the application:
>>> monitor.filter_by('input')
When the monitor is eventually set up, you can either poll for events
synchronously:
>>> device = monitor.poll(timeout=3)
>>> if device:
... print('{0.action}: {0}'.format(device))
...
Or you can monitor events asynchronously with :class:`MonitorObserver`.
To integrate into various event processing frameworks, the monitor provides
a :func:`selectable <select.select>` file description by :meth:`fileno()`.
However, do *not* read or write directly on this file descriptor.
Instances of this class can directly be given as ``udev_monitor *`` to
functions wrapped through :mod:`ctypes`.
.. versionchanged:: 0.16
Remove :meth:`from_socket()` which is deprecated, and even removed in
recent udev versions.
c C s || _ || _|j| _d| _d S )NF)�contextZ_as_parameter_�_libudev�_started)�selfr Z monitor_p� r � /usr/lib/python3.6/monitor.py�__init__V s zMonitor.__init__c C s | j j| � d S )N)r Zudev_monitor_unref)r r r r �__del__\ s zMonitor.__del__�udevc C s> |dkrt dj|���|jj|t|��}|s4td��| ||�S )a�
Create a monitor by connecting to the kernel daemon through netlink.
``context`` is the :class:`Context` to use. ``source`` is a string,
describing the event source. Two sources are available:
``'udev'`` (the default)
Events emitted after udev as registered and configured the device.
This is the absolutely recommended source for applications.
``'kernel'``
Events emitted directly after the kernel has seen the device. The
device has not yet been configured by udev and might not be usable
at all. **Never** use this, unless you know what you are doing.
Return a new :class:`Monitor` object, which is connected to the
given source. Raise :exc:`~exceptions.ValueError`, if an invalid
source has been specified. Raise
:exc:`~exceptions.EnvironmentError`, if the creation of the monitor
failed.
�kernelr z8Invalid source: {0!r}. Must be one of "udev" or "kernel"z Could not create udev monitor)r r )�
ValueError�formatr Z udev_monitor_new_from_netlinkr
�EnvironmentError)�clsr �source�monitorr r r � from_netlink_ s zMonitor.from_netlinkc C s | j S )z�
``True``, if this monitor was started, ``False`` otherwise. Readonly.
.. seealso:: :meth:`start()`
.. versionadded:: 0.16
)r )r r r r �started s zMonitor.startedc C s | j j| �S )z�
Return the file description associated with this monitor as integer.
This is really a real file descriptor ;), which can be watched and
:func:`select.select`\ ed.
)r Zudev_monitor_get_fd)r r r r �fileno� s zMonitor.filenoNc C s8 t |�}|dk rt |�}| jj| ||� | jj| � dS )a
Filter incoming events.
``subsystem`` is a byte or unicode string with the name of a
subsystem (e.g. ``'input'``). Only events originating from the
given subsystem pass the filter and are handed to the caller.
If given, ``device_type`` is a byte or unicode string specifying the
device type. Only devices with the given device type are propagated
to the caller. If ``device_type`` is not given, no additional
filter for a specific device type is installed.
These filters are executed inside the kernel, and client processes
will usually not be woken up for device, that do not match these
filters.
.. versionchanged:: 0.15
This method can also be after :meth:`start()` now.
N)r
r Z/udev_monitor_filter_add_match_subsystem_devtype�udev_monitor_filter_update)r Z subsystemZ device_typer r r � filter_by� s
zMonitor.filter_byc C s" | j j| t|�� | j j| � dS )aR
Filter incoming events by the given ``tag``.
``tag`` is a byte or unicode string with the name of a tag. Only
events for devices which have this tag attached pass the filter and are
handed to the caller.
Like with :meth:`filter_by` this filter is also executed inside the
kernel, so that client processes are usually not woken up for devices
without the given ``tag``.
.. udevversion:: 154
.. versionadded:: 0.9
.. versionchanged:: 0.15
This method can also be after :meth:`start()` now.
N)r Z!udev_monitor_filter_add_match_tagr
r! )r �tagr r r �
filter_by_tag� s zMonitor.filter_by_tagc C s | j j| � | j j| � dS )a
Remove any filters installed with :meth:`filter_by()` or
:meth:`filter_by_tag()` from this monitor.
.. warning::
Up to udev 181 (and possibly even later versions) the underlying
``udev_monitor_filter_remove()`` seems to be broken. If used with
affected versions this method always raises
:exc:`~exceptions.ValueError`.
Raise :exc:`~exceptions.EnvironmentError` if removal of installed
filters failed.
.. versionadded:: 0.15
N)r Zudev_monitor_filter_remover! )r r r r �
remove_filter� s zMonitor.remove_filterc C s ddl }|jdt� | j� dS )a�
Switch the monitor into listing mode.
Connect to the event source and receive incoming events. Only after
calling this method, the monitor listens for incoming events.
.. note::
This method is implicitly called by :meth:`__iter__`. You don't
need to call it explicitly, if you are iterating over the
monitor.
.. deprecated:: 0.16
Will be removed in 1.0. Use :meth:`start()` instead.
r Nz4Will be removed in 1.0. Use Monitor.start() instead.)�warnings�warn�DeprecationWarning�start)r r& r r r �enable_receiving� s zMonitor.enable_receivingc C s* | j s&| jj| � tj| tj� d| _ dS )a�
Start this monitor.
The monitor will not receive events until this method is called. This
method does nothing if called on an already started :class:`Monitor`.
.. note::
Typically you don't need to call this method. It is implicitly
called by :meth:`poll()` and :meth:`__iter__()`.
.. seealso:: :attr:`started`
.. versionchanged:: 0.16
This method does nothing if the :class:`Monitor` was already
started.
TN)r r Z udev_monitor_enable_receivingr Zset_fd_status_flag�os�
O_NONBLOCK)r r r r r) � s z
Monitor.startc C s | j j| |� dS )aN
Set the receive buffer ``size``.
``size`` is the requested buffer size in bytes, as integer.
.. note::
The CAP_NET_ADMIN capability must be contained in the effective
capability set of the caller for this method to succeed. Otherwise
:exc:`~exceptions.EnvironmentError` will be raised, with ``errno``
set to :data:`~errno.EPERM`. Unprivileged processes typically lack
this capability. You can check the capabilities of the current
process with the python-prctl_ module:
>>> import prctl
>>> prctl.cap_effective.net_admin
Raise :exc:`~exceptions.EnvironmentError`, if the buffer size could not
bet set.
.. versionadded:: 0.13
.. _python-prctl: http://packages.python.org/python-prctl
N)r Z$udev_monitor_set_receive_buffer_size)r �sizer r r �set_receive_buffer_size s z Monitor.set_receive_buffer_sizec C sv xpy | j j| �}|r t| j|�S dS tk
rl } z.|jtjtjfkrJdS |jtjkrZwn� W Y dd}~X qX qW dS )z�Receive a single device from the monitor.
Return the received :class:`Device`, or ``None`` if no device could be
received.
N) r Zudev_monitor_receive_devicer r r �errnoZEAGAINZ EWOULDBLOCKZEINTR)r Zdevice_p�errorr r r �_receive_device s zMonitor._receive_devicec C sL |dk r |dkr t |d �}| j� ttjj| df�j|�rD| j� S dS dS )a�
Poll for a device event.
You can use this method together with :func:`iter()` to synchronously
monitor events in the current thread::
for device in iter(monitor.poll, None):
print('{0.action} on {0.device_path}'.format(device))
Since this method will never return ``None`` if no ``timeout`` is
specified, this is effectively an endless loop. With
:func:`functools.partial()` you can also create a loop that only waits
for a specified time::
for device in iter(partial(monitor.poll, 3), None):
print('{0.action} on {0.device_path}'.format(device))
This loop will only wait three seconds for a new device event. If no
device event occurred after three seconds, the loop will exit.
``timeout`` is a floating point number that specifies a time-out in
seconds. If omitted or ``None``, this method blocks until a device
event is available. If ``0``, this method just polls and will never
block.
.. note::
This method implicitly calls :meth:`start()`.
Return the received :class:`Device`, or ``None`` if a timeout
occurred. Raise :exc:`~exceptions.EnvironmentError` if event retrieval
failed.
.. seealso::
:attr:`Device.action`
The action that created this event.
:attr:`Device.sequence_number`
The sequence number of this event.
.. versionadded:: 0.16
Nr i� �r)�intr) r r �Poll�
for_eventsr1 )r �timeoutr r r r 5 s , z Monitor.pollc C s& ddl }|jdt� | j� }|j|fS )a:
Receive a single device from the monitor.
.. warning::
You *must* call :meth:`start()` before calling this method.
The caller must make sure, that there are events available in the
event queue. The call blocks, until a device is available.
If a device was available, return ``(action, device)``. ``device``
is the :class:`Device` object describing the device. ``action`` is
a string describing the action. Usual actions are:
``'add'``
A device has been added (e.g. a USB device was plugged in)
``'remove'``
A device has been removed (e.g. a USB device was unplugged)
``'change'``
Something about the device changed (e.g. a device property)
``'online'``
The device is online now
``'offline'``
The device is offline now
Raise :exc:`~exceptions.EnvironmentError`, if no device could be
read.
.. deprecated:: 0.16
Will be removed in 1.0. Use :meth:`Monitor.poll()` instead.
r Nz3Will be removed in 1.0. Use Monitor.poll() instead.)r& r' r( r �action)r r& �devicer r r �receive_devicej s
zMonitor.receive_devicec c sB ddl }|jdt� | j� x | j� }|dk r |j|fV q W dS )a�
Wait for incoming events and receive them upon arrival.
This methods implicitly calls :meth:`start()`, and starts polling the
:meth:`fileno` of this monitor. If a event comes in, it receives the
corresponding device and yields it to the caller.
The returned iterator is endless, and continues receiving devices
without ever stopping.
Yields ``(action, device)`` (see :meth:`receive_device` for a
description).
.. deprecated:: 0.16
Will be removed in 1.0. Use an explicit loop over :meth:`poll()`
instead, or monitor asynchronously with :class:`MonitorObserver`.
r NzuWill be removed in 1.0. Use an explicit loop over "poll()" instead, or monitor asynchronously with "MonitorObserver".)r& r' r( r) r r7 )r r& r8 r r r �__iter__� s zMonitor.__iter__)r )N)N)�__name__�
__module__� __qualname__�__doc__r r � classmethodr �propertyr r r" r$ r% r* r) r. r1 r r9 r: r r r r r
. s" &
5&r
c @ s: e Zd ZdZd
dd�Zdd� Zdd� Zd d
� Zd d � ZdS )�MonitorObservera`
An asynchronous observer for device events.
This class subclasses :class:`~threading.Thread` class to asynchronously
observe a :class:`Monitor` in a background thread:
>>> from pyudev import Context, Monitor, MonitorObserver
>>> context = Context()
>>> monitor = Monitor.from_netlink(context)
>>> monitor.filter_by(subsystem='input')
>>> def print_device_event(device):
... print('background event {0.action}: {0.device_path}'.format(device))
>>> observer = MonitorObserver(monitor, callback=print_device_event, name='monitor-observer')
>>> observer.daemon
True
>>> observer.start()
In the above example, input device events will be printed in background,
until :meth:`stop()` is called on ``observer``.
.. note::
Instances of this class are always created as daemon thread. If you do
not want to use daemon threads for monitoring, you need explicitly set
:attr:`~threading.Thread.daemon` to ``False`` before invoking
:meth:`~threading.Thread.start()`.
.. seealso::
:attr:`Device.action`
The action that created this event.
:attr:`Device.sequence_number`
The sequence number of this event.
.. versionadded:: 0.14
.. versionchanged:: 0.15
:meth:`Monitor.start()` is implicitly called when the thread is started.
Nc s� |dkr� dkrt d��n|dk r2� dk r2t d��tj| f|�|� || _d| _d| _� dk r~ddl}|jdt� � fdd�}|| _ dS ) a
Create a new observer for the given ``monitor``.
``monitor`` is the :class:`Monitor` to observe. ``callback`` is the
callable to invoke on events, with the signature ``callback(device)``
where ``device`` is the :class:`Device` that caused the event.
.. warning::
``callback`` is invoked in the observer thread, hence the observer
is blocked while callback executes.
``args`` and ``kwargs`` are passed unchanged to the constructor of
:class:`~threading.Thread`.
.. deprecated:: 0.16
The ``event_handler`` argument will be removed in 1.0. Use
the ``callback`` argument instead.
.. versionchanged:: 0.16
Add ``callback`` argument.
Nzcallback missingz$Use either callback or event handlerTr zL"event_handler" argument will be removed in 1.0. Use Monitor.poll() instead.c s � | j | �S )N)r7 )�d)�
event_handlerr r �<lambda>� s z*MonitorObserver.__init__.<locals>.<lambda>)
r r r r Zdaemon� _stop_eventr& r' r( � _callback)r r rC �callback�args�kwargsr& r )rC r r � s
zMonitorObserver.__init__c C s" | j � stjj� | _tj| � dS )zStart the observer thread.N)Zis_aliver ZPipe�openrE r r) )r r r r r) � s zMonitorObserver.startc C s� | j j� tjj| j df| jjdf�}x�x�t|j�D ]x\}}|| jjj� kr\| jjj � d S || j j� kr�|dkr�t
t| j jdd�}x&t |d �D ]}| j |� q�W q4t
d��q4W q(W d S )Nr2 r )r6 zObserved monitor hung up)r r) r r4 r5 rE r r r �closer �iterrF r )r ZnotifierZfile_descriptorZeventZ read_devicer8 r r r �run s
zMonitorObserver.runc
C sB | j dkrdS | j j�" t| j jjd� | j jj� W dQ R X dS )aT
Send a stop signal to the background thread.
The background thread will eventually exit, but it may still be running
when this method returns. This method is essentially the asynchronous
equivalent to :meth:`stop()`.
.. note::
The underlying :attr:`monitor` is *not* stopped.
N� )rE Zsinkr �write�flush)r r r r � send_stop s
zMonitorObserver.send_stopc C s. | j � y | j� W n tk
r( Y nX dS )a
Synchronously stop the background thread.
.. note::
This method can safely be called from the observer thread. In this
case it is equivalent to :meth:`send_stop()`.
Send a stop signal to the backgroud (see :meth:`send_stop`), and waits
for the background thread to exit (see :meth:`~threading.Thread.join`)
if the current thread is *not* the observer thread.
After this method returns in a thread *that is not the observer
thread*, the ``callback`` is guaranteed to not be invoked again
anymore.
.. note::
The underlying :attr:`monitor` is *not* stopped.
.. versionchanged:: 0.16
This method can be called from the observer thread.
N)rQ �join� RuntimeError)r r r r �stop* s
zMonitorObserver.stop)NN) r; r< r= r> r r) rM rQ rT r r r r rA � s (
(rA )r> Z
__future__r r r r r+ r/ Z threadingr � functoolsr Z
pyudev.devicer Z pyudev._utilr r
Z
pyudev._osr r �objectr
rA r r r r �<module> s __pycache__/monitor.cpython-36.opt-1.pyc 0000644 00000046361 15035142004 0014034 0 ustar 00 3
u1�W�Q � @ s� d Z ddlmZmZmZmZ ddlZddlZddlm Z ddl
m Z ddl m
Z
ddlmZ ddlmZ dd lmZ dd
lmZ G d d � d e�ZG d
d� de �ZdS )z�
pyudev.monitor
==============
Monitor implementation.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�print_function�division�unicode_literals�absolute_importN)�Thread)�partial)�Device)�eintr_retry_call)�ensure_byte_string)�pipe)�pollc @ s� e Zd ZdZdd� Zdd� Zed"dd��Zed d
� �Z d d � Z
d#dd�Z dd� Z dd� Z
dd� Zdd� Zdd� Zdd� Zd$d d �Zd d � Zd d!� Zd
S )%�Monitorat
A synchronous device event monitor.
A :class:`Monitor` objects connects to the udev daemon and listens for
changes to the device list. A monitor is created by connecting to the
kernel daemon through netlink (see :meth:`from_netlink`):
>>> from pyudev import Context, Monitor
>>> context = Context()
>>> monitor = Monitor.from_netlink(context)
Once the monitor is created, you can add a filter using :meth:`filter_by()`
or :meth:`filter_by_tag()` to drop incoming events in subsystems, which are
not of interest to the application:
>>> monitor.filter_by('input')
When the monitor is eventually set up, you can either poll for events
synchronously:
>>> device = monitor.poll(timeout=3)
>>> if device:
... print('{0.action}: {0}'.format(device))
...
Or you can monitor events asynchronously with :class:`MonitorObserver`.
To integrate into various event processing frameworks, the monitor provides
a :func:`selectable <select.select>` file description by :meth:`fileno()`.
However, do *not* read or write directly on this file descriptor.
Instances of this class can directly be given as ``udev_monitor *`` to
functions wrapped through :mod:`ctypes`.
.. versionchanged:: 0.16
Remove :meth:`from_socket()` which is deprecated, and even removed in
recent udev versions.
c C s || _ || _|j| _d| _d S )NF)�contextZ_as_parameter_�_libudev�_started)�selfr Z monitor_p� r � /usr/lib/python3.6/monitor.py�__init__V s zMonitor.__init__c C s | j j| � d S )N)r Zudev_monitor_unref)r r r r �__del__\ s zMonitor.__del__�udevc C s> |dkrt dj|���|jj|t|��}|s4td��| ||�S )a�
Create a monitor by connecting to the kernel daemon through netlink.
``context`` is the :class:`Context` to use. ``source`` is a string,
describing the event source. Two sources are available:
``'udev'`` (the default)
Events emitted after udev as registered and configured the device.
This is the absolutely recommended source for applications.
``'kernel'``
Events emitted directly after the kernel has seen the device. The
device has not yet been configured by udev and might not be usable
at all. **Never** use this, unless you know what you are doing.
Return a new :class:`Monitor` object, which is connected to the
given source. Raise :exc:`~exceptions.ValueError`, if an invalid
source has been specified. Raise
:exc:`~exceptions.EnvironmentError`, if the creation of the monitor
failed.
�kernelr z8Invalid source: {0!r}. Must be one of "udev" or "kernel"z Could not create udev monitor)r r )�
ValueError�formatr Z udev_monitor_new_from_netlinkr
�EnvironmentError)�clsr �source�monitorr r r � from_netlink_ s zMonitor.from_netlinkc C s | j S )z�
``True``, if this monitor was started, ``False`` otherwise. Readonly.
.. seealso:: :meth:`start()`
.. versionadded:: 0.16
)r )r r r r �started s zMonitor.startedc C s | j j| �S )z�
Return the file description associated with this monitor as integer.
This is really a real file descriptor ;), which can be watched and
:func:`select.select`\ ed.
)r Zudev_monitor_get_fd)r r r r �fileno� s zMonitor.filenoNc C s8 t |�}|dk rt |�}| jj| ||� | jj| � dS )a
Filter incoming events.
``subsystem`` is a byte or unicode string with the name of a
subsystem (e.g. ``'input'``). Only events originating from the
given subsystem pass the filter and are handed to the caller.
If given, ``device_type`` is a byte or unicode string specifying the
device type. Only devices with the given device type are propagated
to the caller. If ``device_type`` is not given, no additional
filter for a specific device type is installed.
These filters are executed inside the kernel, and client processes
will usually not be woken up for device, that do not match these
filters.
.. versionchanged:: 0.15
This method can also be after :meth:`start()` now.
N)r
r Z/udev_monitor_filter_add_match_subsystem_devtype�udev_monitor_filter_update)r Z subsystemZ device_typer r r � filter_by� s
zMonitor.filter_byc C s" | j j| t|�� | j j| � dS )aR
Filter incoming events by the given ``tag``.
``tag`` is a byte or unicode string with the name of a tag. Only
events for devices which have this tag attached pass the filter and are
handed to the caller.
Like with :meth:`filter_by` this filter is also executed inside the
kernel, so that client processes are usually not woken up for devices
without the given ``tag``.
.. udevversion:: 154
.. versionadded:: 0.9
.. versionchanged:: 0.15
This method can also be after :meth:`start()` now.
N)r Z!udev_monitor_filter_add_match_tagr
r! )r �tagr r r �
filter_by_tag� s zMonitor.filter_by_tagc C s | j j| � | j j| � dS )a
Remove any filters installed with :meth:`filter_by()` or
:meth:`filter_by_tag()` from this monitor.
.. warning::
Up to udev 181 (and possibly even later versions) the underlying
``udev_monitor_filter_remove()`` seems to be broken. If used with
affected versions this method always raises
:exc:`~exceptions.ValueError`.
Raise :exc:`~exceptions.EnvironmentError` if removal of installed
filters failed.
.. versionadded:: 0.15
N)r Zudev_monitor_filter_remover! )r r r r �
remove_filter� s zMonitor.remove_filterc C s ddl }|jdt� | j� dS )a�
Switch the monitor into listing mode.
Connect to the event source and receive incoming events. Only after
calling this method, the monitor listens for incoming events.
.. note::
This method is implicitly called by :meth:`__iter__`. You don't
need to call it explicitly, if you are iterating over the
monitor.
.. deprecated:: 0.16
Will be removed in 1.0. Use :meth:`start()` instead.
r Nz4Will be removed in 1.0. Use Monitor.start() instead.)�warnings�warn�DeprecationWarning�start)r r& r r r �enable_receiving� s zMonitor.enable_receivingc C s* | j s&| jj| � tj| tj� d| _ dS )a�
Start this monitor.
The monitor will not receive events until this method is called. This
method does nothing if called on an already started :class:`Monitor`.
.. note::
Typically you don't need to call this method. It is implicitly
called by :meth:`poll()` and :meth:`__iter__()`.
.. seealso:: :attr:`started`
.. versionchanged:: 0.16
This method does nothing if the :class:`Monitor` was already
started.
TN)r r Z udev_monitor_enable_receivingr Zset_fd_status_flag�os�
O_NONBLOCK)r r r r r) � s z
Monitor.startc C s | j j| |� dS )aN
Set the receive buffer ``size``.
``size`` is the requested buffer size in bytes, as integer.
.. note::
The CAP_NET_ADMIN capability must be contained in the effective
capability set of the caller for this method to succeed. Otherwise
:exc:`~exceptions.EnvironmentError` will be raised, with ``errno``
set to :data:`~errno.EPERM`. Unprivileged processes typically lack
this capability. You can check the capabilities of the current
process with the python-prctl_ module:
>>> import prctl
>>> prctl.cap_effective.net_admin
Raise :exc:`~exceptions.EnvironmentError`, if the buffer size could not
bet set.
.. versionadded:: 0.13
.. _python-prctl: http://packages.python.org/python-prctl
N)r Z$udev_monitor_set_receive_buffer_size)r �sizer r r �set_receive_buffer_size s z Monitor.set_receive_buffer_sizec C sv xpy | j j| �}|r t| j|�S dS tk
rl } z.|jtjtjfkrJdS |jtjkrZwn� W Y dd}~X qX qW dS )z�Receive a single device from the monitor.
Return the received :class:`Device`, or ``None`` if no device could be
received.
N) r Zudev_monitor_receive_devicer r r �errnoZEAGAINZ EWOULDBLOCKZEINTR)r Zdevice_p�errorr r r �_receive_device s zMonitor._receive_devicec C sL |dk r |dkr t |d �}| j� ttjj| df�j|�rD| j� S dS dS )a�
Poll for a device event.
You can use this method together with :func:`iter()` to synchronously
monitor events in the current thread::
for device in iter(monitor.poll, None):
print('{0.action} on {0.device_path}'.format(device))
Since this method will never return ``None`` if no ``timeout`` is
specified, this is effectively an endless loop. With
:func:`functools.partial()` you can also create a loop that only waits
for a specified time::
for device in iter(partial(monitor.poll, 3), None):
print('{0.action} on {0.device_path}'.format(device))
This loop will only wait three seconds for a new device event. If no
device event occurred after three seconds, the loop will exit.
``timeout`` is a floating point number that specifies a time-out in
seconds. If omitted or ``None``, this method blocks until a device
event is available. If ``0``, this method just polls and will never
block.
.. note::
This method implicitly calls :meth:`start()`.
Return the received :class:`Device`, or ``None`` if a timeout
occurred. Raise :exc:`~exceptions.EnvironmentError` if event retrieval
failed.
.. seealso::
:attr:`Device.action`
The action that created this event.
:attr:`Device.sequence_number`
The sequence number of this event.
.. versionadded:: 0.16
Nr i� �r)�intr) r r �Poll�
for_eventsr1 )r �timeoutr r r r 5 s , z Monitor.pollc C s& ddl }|jdt� | j� }|j|fS )a:
Receive a single device from the monitor.
.. warning::
You *must* call :meth:`start()` before calling this method.
The caller must make sure, that there are events available in the
event queue. The call blocks, until a device is available.
If a device was available, return ``(action, device)``. ``device``
is the :class:`Device` object describing the device. ``action`` is
a string describing the action. Usual actions are:
``'add'``
A device has been added (e.g. a USB device was plugged in)
``'remove'``
A device has been removed (e.g. a USB device was unplugged)
``'change'``
Something about the device changed (e.g. a device property)
``'online'``
The device is online now
``'offline'``
The device is offline now
Raise :exc:`~exceptions.EnvironmentError`, if no device could be
read.
.. deprecated:: 0.16
Will be removed in 1.0. Use :meth:`Monitor.poll()` instead.
r Nz3Will be removed in 1.0. Use Monitor.poll() instead.)r& r' r( r �action)r r& �devicer r r �receive_devicej s
zMonitor.receive_devicec c sB ddl }|jdt� | j� x | j� }|dk r |j|fV q W dS )a�
Wait for incoming events and receive them upon arrival.
This methods implicitly calls :meth:`start()`, and starts polling the
:meth:`fileno` of this monitor. If a event comes in, it receives the
corresponding device and yields it to the caller.
The returned iterator is endless, and continues receiving devices
without ever stopping.
Yields ``(action, device)`` (see :meth:`receive_device` for a
description).
.. deprecated:: 0.16
Will be removed in 1.0. Use an explicit loop over :meth:`poll()`
instead, or monitor asynchronously with :class:`MonitorObserver`.
r NzuWill be removed in 1.0. Use an explicit loop over "poll()" instead, or monitor asynchronously with "MonitorObserver".)r& r' r( r) r r7 )r r& r8 r r r �__iter__� s zMonitor.__iter__)r )N)N)�__name__�
__module__� __qualname__�__doc__r r � classmethodr �propertyr r r" r$ r% r* r) r. r1 r r9 r: r r r r r
. s" &
5&r
c @ s: e Zd ZdZd
dd�Zdd� Zdd� Zd d
� Zd d � ZdS )�MonitorObservera`
An asynchronous observer for device events.
This class subclasses :class:`~threading.Thread` class to asynchronously
observe a :class:`Monitor` in a background thread:
>>> from pyudev import Context, Monitor, MonitorObserver
>>> context = Context()
>>> monitor = Monitor.from_netlink(context)
>>> monitor.filter_by(subsystem='input')
>>> def print_device_event(device):
... print('background event {0.action}: {0.device_path}'.format(device))
>>> observer = MonitorObserver(monitor, callback=print_device_event, name='monitor-observer')
>>> observer.daemon
True
>>> observer.start()
In the above example, input device events will be printed in background,
until :meth:`stop()` is called on ``observer``.
.. note::
Instances of this class are always created as daemon thread. If you do
not want to use daemon threads for monitoring, you need explicitly set
:attr:`~threading.Thread.daemon` to ``False`` before invoking
:meth:`~threading.Thread.start()`.
.. seealso::
:attr:`Device.action`
The action that created this event.
:attr:`Device.sequence_number`
The sequence number of this event.
.. versionadded:: 0.14
.. versionchanged:: 0.15
:meth:`Monitor.start()` is implicitly called when the thread is started.
Nc s� |dkr� dkrt d��n|dk r2� dk r2t d��tj| f|�|� || _d| _d| _� dk r~ddl}|jdt� � fdd�}|| _ dS ) a
Create a new observer for the given ``monitor``.
``monitor`` is the :class:`Monitor` to observe. ``callback`` is the
callable to invoke on events, with the signature ``callback(device)``
where ``device`` is the :class:`Device` that caused the event.
.. warning::
``callback`` is invoked in the observer thread, hence the observer
is blocked while callback executes.
``args`` and ``kwargs`` are passed unchanged to the constructor of
:class:`~threading.Thread`.
.. deprecated:: 0.16
The ``event_handler`` argument will be removed in 1.0. Use
the ``callback`` argument instead.
.. versionchanged:: 0.16
Add ``callback`` argument.
Nzcallback missingz$Use either callback or event handlerTr zL"event_handler" argument will be removed in 1.0. Use Monitor.poll() instead.c s � | j | �S )N)r7 )�d)�
event_handlerr r �<lambda>� s z*MonitorObserver.__init__.<locals>.<lambda>)
r r r r Zdaemon� _stop_eventr& r' r( � _callback)r r rC �callback�args�kwargsr& r )rC r r � s
zMonitorObserver.__init__c C s" | j � stjj� | _tj| � dS )zStart the observer thread.N)Zis_aliver ZPipe�openrE r r) )r r r r r) � s zMonitorObserver.startc C s� | j j� tjj| j df| jjdf�}x�x�t|j�D ]x\}}|| jjj� kr\| jjj � d S || j j� kr�|dkr�t
t| j jdd�}x&t |d �D ]}| j |� q�W q4t
d��q4W q(W d S )Nr2 r )r6 zObserved monitor hung up)r r) r r4 r5 rE r r r �closer �iterrF r )r ZnotifierZfile_descriptorZeventZ read_devicer8 r r r �run s
zMonitorObserver.runc
C sB | j dkrdS | j j�" t| j jjd� | j jj� W dQ R X dS )aT
Send a stop signal to the background thread.
The background thread will eventually exit, but it may still be running
when this method returns. This method is essentially the asynchronous
equivalent to :meth:`stop()`.
.. note::
The underlying :attr:`monitor` is *not* stopped.
N� )rE Zsinkr �write�flush)r r r r � send_stop s
zMonitorObserver.send_stopc C s. | j � y | j� W n tk
r( Y nX dS )a
Synchronously stop the background thread.
.. note::
This method can safely be called from the observer thread. In this
case it is equivalent to :meth:`send_stop()`.
Send a stop signal to the backgroud (see :meth:`send_stop`), and waits
for the background thread to exit (see :meth:`~threading.Thread.join`)
if the current thread is *not* the observer thread.
After this method returns in a thread *that is not the observer
thread*, the ``callback`` is guaranteed to not be invoked again
anymore.
.. note::
The underlying :attr:`monitor` is *not* stopped.
.. versionchanged:: 0.16
This method can be called from the observer thread.
N)rQ �join� RuntimeError)r r r r �stop* s
zMonitorObserver.stop)NN) r; r< r= r> r r) rM rQ rT r r r r rA � s (
(rA )r> Z
__future__r r r r r+ r/ Z threadingr � functoolsr Z
pyudev.devicer Z pyudev._utilr r
Z
pyudev._osr r �objectr
rA r r r r �<module> s __pycache__/core.cpython-36.opt-1.pyc 0000644 00000031216 15035142004 0013266 0 ustar 00 3
u1�Ws4 � @ s� d Z ddlmZmZmZmZ ddlmZ ddlm Z ddl
m Z ddl
m Z ddl
mZ ddlmZ dd lmZ dd
lmZ dd lmZ G d d
� d
e�ZG dd� de�ZdS )z�
pyudev.core
===========
Core types and functions of :mod:`pyudev`.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�print_function�division�unicode_literals�absolute_import)�Devices)�DeviceNotFoundAtPathError)�ERROR_CHECKERS)�
SIGNATURES)�load_ctypes_library)�ensure_byte_string)�ensure_unicode_string)�property_value_to_bytes)�udev_list_iteratec @ sf e Zd ZdZdd� Zdd� Zedd� �Zedd � �Zed
d � �Z ed d
� �Z
e
j dd
� �Z
dd� Z dS )�Contexta
A device database connection.
This class represents a connection to the udev device database, and is
really *the* central object to access udev. You need an instance of this
class for almost anything else in pyudev.
This class itself gives access to various udev configuration data (e.g.
:attr:`sys_path`, :attr:`device_path`), and provides device enumeration
(:meth:`list_devices()`).
Instances of this class can directly be given as ``udev *`` to functions
wrapped through :mod:`ctypes`.
c C s t dtt�| _| jj� | _dS )z'
Create a new context.
ZudevN)r
r r �_libudevZudev_new�_as_parameter_)�self� r �/usr/lib/python3.6/core.py�__init__< s zContext.__init__c C s | j j| � d S )N)r Z
udev_unref)r r r r �__del__C s zContext.__del__c C s$ t | jd�r t| jj| ��S dS dS )zV
The ``sysfs`` mount point defaulting to ``/sys'`` as unicode string.
�udev_get_sys_pathz/sysN)�hasattrr r r )r r r r �sys_pathF s zContext.sys_pathc C s$ t | jd�r t| jj| ��S dS dS )zU
The device directory path defaulting to ``/dev`` as unicode string.
�udev_get_dev_pathz/devN)r r r r )r r r r � device_pathQ s zContext.device_pathc C s$ t | jd�r t| jj| ��S dS dS )z�
The run runtime directory path defaulting to ``/run`` as unicode
string.
.. udevversion:: 167
.. versionadded:: 0.10
�udev_get_run_pathz /run/udevN)r r r r )r r r r �run_path\ s
zContext.run_pathc C s | j j| �S )a
The logging priority of the interal logging facitility of udev as
integer with a standard :mod:`syslog` priority. Assign to this
property to change the logging priority.
UDev uses the standard :mod:`syslog` priorities. Constants for these
priorities are defined in the :mod:`syslog` module in the standard
library:
>>> import syslog
>>> context = pyudev.Context()
>>> context.log_priority = syslog.LOG_DEBUG
.. versionadded:: 0.9
)r Zudev_get_log_priority)r r r r � log_priorityk s zContext.log_priorityc C s | j j| |� dS )zT
Set the log priority.
:param int value: the log priority.
N)r Zudev_set_log_priority)r �valuer r r r ~ s c K s t | �jf |�S )a"
List all available devices.
The arguments of this method are the same as for
:meth:`Enumerator.match()`. In fact, the arguments are simply passed
straight to method :meth:`~Enumerator.match()`.
This function creates and returns an :class:`Enumerator` object,
that can be used to filter the list of devices, and eventually
retrieve :class:`Device` objects representing matching devices.
.. versionchanged:: 0.8
Accept keyword arguments now for easy matching.
)�
Enumerator�match)r �kwargsr r r � list_devices� s zContext.list_devicesN)
�__name__�
__module__� __qualname__�__doc__r r �propertyr r r r �setterr# r r r r r , s r c @ sl e Zd ZdZdd� Zdd� Zdd� Zdd d
�Zd d � Zd
d� Z ddd�Z
dd� Z dd� Z dd� Z
dd� ZdS ) r a�
A filtered iterable of devices.
To retrieve devices, simply iterate over an instance of this class.
This operation yields :class:`Device` objects representing the available
devices.
Before iteration the device list can be filtered by subsystem or by
property values using :meth:`match_subsystem` and
:meth:`match_property`. Multiple subsystem (property) filters are
combined using a logical OR, filters of different types are combined
using a logical AND. The following filter for instance::
devices.match_subsystem('block').match_property(
'ID_TYPE', 'disk').match_property('DEVTYPE', 'disk')
means the following::
subsystem == 'block' and (ID_TYPE == 'disk' or DEVTYPE == 'disk')
Once added, a filter cannot be removed anymore. Create a new object
instead.
Instances of this class can directly be given as given ``udev_enumerate *``
to functions wrapped through :mod:`ctypes`.
c C s2 t |t�std��|| _|jj|�| _|j| _dS )z�
Create a new enumerator with the given ``context`` (a
:class:`Context` instance).
While you can create objects of this class directly, this is not
recommended. Call :method:`Context.list_devices()` instead.
zInvalid context objectN)�
isinstancer � TypeError�contextr Zudev_enumerate_newr )r r, r r r r � s
zEnumerator.__init__c C s | j j| � d S )N)r Zudev_enumerate_unref)r r r r r � s zEnumerator.__del__c K s� |j dd�}|dk r | j|� |j dd�}|dk r<| j|� |j dd�}|dk rZ| j|� |j dd�}|dk rx| j|� x |j� D ]\}}| j||� q�W | S )a2
Include devices according to the rules defined by the keyword
arguments. These keyword arguments are interpreted as follows:
- The value for the keyword argument ``subsystem`` is forwarded to
:meth:`match_subsystem()`.
- The value for the keyword argument ``sys_name`` is forwared to
:meth:`match_sys_name()`.
- The value for the keyword argument ``tag`` is forwared to
:meth:`match_tag()`.
- The value for the keyword argument ``parent`` is forwared to
:meth:`match_parent()`.
- All other keyword arguments are forwareded one by one to
:meth:`match_property()`. The keyword argument itself is interpreted
as property name, the value of the keyword argument as the property
value.
All keyword arguments are optional, calling this method without no
arguments at all is simply a noop.
Return the instance again.
.. versionadded:: 0.8
.. versionchanged:: 0.13
Add ``parent`` keyword.
� subsystemN�sys_name�tag�parent)�pop�match_subsystem�match_sys_name� match_tag� match_parent�items�match_property)r r" r- r. r/ r0 �propr r r r r! � s
zEnumerator.matchFc C s& |r | j jn| j j}|| t|�� | S )a$
Include all devices, which are part of the given ``subsystem``.
``subsystem`` is either a unicode string or a byte string, containing
the name of the subsystem. If ``nomatch`` is ``True`` (default is
``False``), the match is inverted: A device is only included if it is
*not* part of the given ``subsystem``.
Note that, if a device has no subsystem, it is not included either
with value of ``nomatch`` True or with value of ``nomatch`` False.
Return the instance again.
)r Z$udev_enumerate_add_nomatch_subsystemZ"udev_enumerate_add_match_subsystemr )r r- �nomatchr! r r r r2 � s zEnumerator.match_subsystemc C s | j j| t|�� | S )z�
Include all devices with the given name.
``sys_name`` is a byte or unicode string containing the device name.
Return the instance again.
.. versionadded:: 0.8
)r Z udev_enumerate_add_match_sysnamer )r r. r r r r3 s
zEnumerator.match_sys_namec C s | j j| t|�t|�� | S )a�
Include all devices, whose ``prop`` has the given ``value``.
``prop`` is either a unicode string or a byte string, containing
the name of the property to match. ``value`` is a property value,
being one of the following types:
- :func:`int`
- :func:`bool`
- A byte string
- Anything convertable to a unicode string (including a unicode string
itself)
Return the instance again.
)r Z!udev_enumerate_add_match_propertyr r
)r r8 r r r r r7 s zEnumerator.match_propertyc C s, |s | j jn| j j}|| t|�t|�� | S )a�
Include all devices, whose ``attribute`` has the given ``value``.
``attribute`` is either a unicode string or a byte string, containing
the name of a sys attribute to match. ``value`` is an attribute value,
being one of the following types:
- :func:`int`,
- :func:`bool`
- A byte string
- Anything convertable to a unicode string (including a unicode string
itself)
If ``nomatch`` is ``True`` (default is ``False``), the match is
inverted: A device is include if the ``attribute`` does *not* match
the given ``value``.
.. note::
If ``nomatch`` is ``True``, devices which do not have the given
``attribute`` at all are also included. In other words, with
``nomatch=True`` the given ``attribute`` is *not* guaranteed to
exist on all returned devices.
Return the instance again.
)r Z udev_enumerate_add_match_sysattrZ"udev_enumerate_add_nomatch_sysattrr r
)r Z attributer r9 r! r r r �match_attribute' s
zEnumerator.match_attributec C s | j j| t|�� | S )z�
Include all devices, which have the given ``tag`` attached.
``tag`` is a byte or unicode string containing the tag name.
Return the instance again.
.. udevversion:: 154
.. versionadded:: 0.6
)r Z udev_enumerate_add_match_tagr )r r/ r r r r4 I s zEnumerator.match_tagc C s | j j| � | S )a�
Include only devices, which are initialized.
Initialized devices have properly set device node permissions and
context, and are (in case of network devices) fully renamed.
Currently this will not affect devices which do not have device nodes
and are not network interfaces.
Return the instance again.
.. seealso:: :attr:`Device.is_initialized`
.. udevversion:: 165
.. versionadded:: 0.8
)r Z'udev_enumerate_add_match_is_initialized)r r r r �match_is_initializedX s z Enumerator.match_is_initializedc C s | j j| |� | S )a
Include all devices on the subtree of the given ``parent`` device.
The ``parent`` device itself is also included.
``parent`` is a :class:`~pyudev.Device`.
Return the instance again.
.. udevversion:: 172
.. versionadded:: 0.13
)r Z udev_enumerate_add_match_parent)r r0 r r r r5 m s zEnumerator.match_parentc c sb | j j| � | j j| �}xDt| j |�D ]4\}}ytj| j|�V W q& tk
rX w&Y q&X q&W dS )z\
Iterate over all matching devices.
Yield :class:`Device` objects.
N)r Zudev_enumerate_scan_devicesZ udev_enumerate_get_list_entryr r Z
from_sys_pathr, r )r �entry�name�_r r r �__iter__~ s zEnumerator.__iter__N)F)F)r$ r% r& r' r r r! r2 r3 r7 r: r4 r; r5 r? r r r r r � s ,
"r N)r' Z
__future__r r r r Z
pyudev.devicer Zpyudev.device._errorsr Zpyudev._ctypeslib.libudevr r Zpyudev._ctypeslib.utilsr
Z pyudev._utilr r r
r �objectr r r r r r �<module> s m __pycache__/_qt_base.cpython-36.opt-1.pyc 0000644 00000014331 15035142004 0014112 0 ustar 00 3
u1�Wk � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlmZ G dd � d e �Z
G d
d � d e
�Z d d
� Z G dd� de �Z
G dd� de �ZdS )z�
pyudev._qt_base
===============
Base mixin class for Qt4,Qt5 support.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literalsN)�Devicec @ sB e Zd ZdZdd� Zedd� �Zejdd� �Zdd� Zd d
� Z d S ) �MonitorObserverMixinz0
Base mixin for pyqt monitor observers.
c C s2 || _ ||j� |j| �| _| jjt j| j� d S )N)�monitor�filenoZRead�notifierZ activated�intZconnect�_process_udev_event)�selfr �notifier_class� r � /usr/lib/python3.6/_qt_base.py�_setup_notifier+ s z$MonitorObserverMixin._setup_notifierc C s
| j j� S )aY
Whether this observer is enabled or not.
If ``True`` (the default), this observer is enabled, and emits events.
Otherwise it is disabled and does not emit any events. This merely
reflects the state of the ``enabled`` property of the underlying
:attr:`notifier`.
.. versionadded:: 0.14
)r
Z isEnabled)r
r r r �enabled1 s z MonitorObserverMixin.enabledc C s | j j|� d S )N)r
Z
setEnabled)r
�valuer r r r ? s c C s$ | j jdd�}|dk r | j|� dS )z�
Attempt to receive a single device event from the monitor, process
the event and emit corresponding signals.
Called by ``QSocketNotifier``, if data is available on the udev
monitoring socket.
r )ZtimeoutN)r Zpoll� _emit_event)r
�devicer r r r C s z(MonitorObserverMixin._process_udev_eventc C s | j j|� d S )N)� deviceEvent�emit)r
r r r r r O s z MonitorObserverMixin._emit_eventN)
�__name__�
__module__� __qualname__�__doc__r �propertyr �setterr r r r r r r % s r c @ s e Zd ZdZdd� Zdd� ZdS )�QUDevMonitorObserverMixinz*
Obsolete monitor observer mixin.
c C s> t j| ||� | j| j| j| jd�| _dd l}|jdt � d S )N)�add�removeZchangeZmover zAWill be removed in 1.0. Use pyudev.pyqt4.MonitorObserver instead.)
r r � deviceAdded�
deviceRemoved�
deviceChanged� deviceMoved�_action_signal_map�warnings�warn�DeprecationWarning)r
r r r& r r r r Y s z)QUDevMonitorObserverMixin._setup_notifierc C s4 | j j|j|� | jj|j�}|d k r0|j|� d S )N)r r �actionr% �get)r
r �signalr r r r d s z%QUDevMonitorObserverMixin._emit_eventN)r r r r r r r r r r r S s r c s d� �fdd� }|S )a
Generates an initializer to observer the given ``monitor``
(a :class:`~pyudev.Monitor`):
``parent`` is the parent :class:`~PyQt{4,5}.QtCore.QObject` of this
object. It is passed unchanged to the inherited constructor of
:class:`~PyQt{4,5}.QtCore.QObject`.
Nc s � j | |� | j|�� d S )N)�__init__r )r
r �parent)�qobject�socket_notifierr r r, t s zmake_init.<locals>.__init__)Nr )r. r/ r, r )r. r/ r � make_initj s
r0 c @ s e Zd ZdZedd� �ZdS )�MonitorObserverGeneratorz4
Class to generate a MonitorObserver class.
c C s. t td�| tftd�t| |�td�|t�i�S )a Generates an observer for device events integrating into the
PyQt{4,5} mainloop.
This class inherits :class:`~PyQt{4,5}.QtCore.QObject` to turn device
events into Qt signals:
>>> from pyudev import Context, Monitor
>>> from pyudev.pyqt4 import MonitorObserver
>>> context = Context()
>>> monitor = Monitor.from_netlink(context)
>>> monitor.filter_by(subsystem='input')
>>> observer = MonitorObserver(monitor)
>>> def device_event(device):
... print('event {0} on device {1}'.format(device.action, device))
>>> observer.deviceEvent.connect(device_event)
>>> monitor.start()
This class is a child of :class:`~{PySide, PyQt{4,5}}.QtCore.QObject`.
ZMonitorObserverr, r )�type�strr r0 r )r. r+ r/ r r r �make_monitor_observer� s
z.MonitorObserverGenerator.make_monitor_observerN)r r r r � staticmethodr4 r r r r r1 | s r1 c @ s e Zd ZdZedd� �ZdS )� QUDevMonitorObserverGeneratorz4
Class to generate a MonitorObserver class.
c C sb t td�| tftd�t| |�td�|tjt�td�|t�td�|t�td�|t�td�|t�i�S )a Generates an observer for device events integrating into the
PyQt{4,5} mainloop.
This class inherits :class:`~PyQt{4,5}.QtCore.QObject` to turn device
events into Qt signals:
>>> from pyudev import Context, Monitor
>>> from pyudev.pyqt4 import MonitorObserver
>>> context = Context()
>>> monitor = Monitor.from_netlink(context)
>>> monitor.filter_by(subsystem='input')
>>> observer = MonitorObserver(monitor)
>>> def device_event(device):
... print('event {0} on device {1}'.format(device.action, device))
>>> observer.deviceEvent.connect(device_event)
>>> monitor.start()
This class is a child of :class:`~{PyQt{4,5}, PySide}.QtCore.QObject`.
ZQUDevMonitorObserverr, r r! r" r# r$ )r2 r3 r r0 �sixZ text_typer )r. r+ r/ r r r r4 � s z3QUDevMonitorObserverGenerator.make_monitor_observerN)r r r r r5 r4 r r r r r6 � s r6 )r Z
__future__r r r r r7 Z
pyudev.devicer �objectr r r0 r1 r6 r r r r �<module> s .' __pycache__/_compat.cpython-36.opt-1.pyc 0000644 00000001476 15035142004 0013765 0 ustar 00 3
װV� � @ s< d Z ddlmZmZmZmZ ddlmZmZm Z dd� Z
dS )z�
pyudev._compat
==============
Compatibility for Python versions, that lack certain functions.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�print_function�division�unicode_literals�absolute_import)�Popen�CalledProcessError�PIPEc C s2 t | td�}|j� d }|jdkr.t|j| ��|S )z]
Compatibility with :func:`subprocess.check_output` from Python 2.7 and
upwards.
)�stdoutr )r r Z communicate�
returncoder )Zcommand�proc�output� r
� /usr/lib/python3.6/_compat.py� check_output# s
r N) �__doc__Z
__future__r r r r �
subprocessr r r r r
r
r
r �<module> s __pycache__/_compat.cpython-36.pyc 0000644 00000001476 15035142004 0013026 0 ustar 00 3
װV� � @ s< d Z ddlmZmZmZmZ ddlmZmZm Z dd� Z
dS )z�
pyudev._compat
==============
Compatibility for Python versions, that lack certain functions.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�print_function�division�unicode_literals�absolute_import)�Popen�CalledProcessError�PIPEc C s2 t | td�}|j� d }|jdkr.t|j| ��|S )z]
Compatibility with :func:`subprocess.check_output` from Python 2.7 and
upwards.
)�stdoutr )r r Z communicate�
returncoder )Zcommand�proc�output� r
� /usr/lib/python3.6/_compat.py� check_output# s
r N) �__doc__Z
__future__r r r r �
subprocessr r r r r
r
r
r �<module> s __pycache__/__init__.cpython-36.pyc 0000644 00000003402 15035142004 0013132 0 ustar 00 3
N�#W� � @ s@ d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z dd lm
Z
dd
lm Z dd lm Z dd lm
Z
dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddl m Z ddl m Z ddl m!Z! d S ) a.
pyudev
======
A binding to libudev.
The :class:`Context` provides the connection to the udev device database
and enumerates devices. Individual devices are represented by the
:class:`Device` class.
Device monitoring is provided by :class:`Monitor` and
:class:`MonitorObserver`. With :mod:`pyudev.pyqt4`, :mod:`pyudev.pyside`,
:mod:`pyudev.glib` and :mod:`pyudev.wx` device monitoring can be integrated
into the event loop of various GUI toolkits.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literals)�
Attributes)�Device)�Devices)�DeviceNotFoundAtPathError)�DeviceNotFoundByFileError)�DeviceNotFoundByNameError)�DeviceNotFoundByNumberError)�DeviceNotFoundError)� DeviceNotFoundInEnvironmentError)�Tags)�DeviceFileHypothesis)�DeviceNameHypothesis)�DeviceNumberHypothesis)�DevicePathHypothesis)� Discovery)�Context)�
Enumerator)�Monitor)�MonitorObserver)� __version__)�__version_info__)� udev_versionN)"�__doc__Z
__future__r r r r Z
pyudev.devicer r r r r
r r r
r r Zpyudev.discoverr r r r r Z pyudev.corer r Zpyudev.monitorr r Zpyudev.versionr r Z pyudev._utilr � r r � /usr/lib/python3.6/__init__.py�<module># s4 __pycache__/__init__.cpython-36.opt-1.pyc 0000644 00000003402 15035142004 0014071 0 ustar 00 3
N�#W� � @ s@ d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z dd lm
Z
dd
lm Z dd lm Z dd lm
Z
dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddl m Z ddl m Z ddl m!Z! d S ) a.
pyudev
======
A binding to libudev.
The :class:`Context` provides the connection to the udev device database
and enumerates devices. Individual devices are represented by the
:class:`Device` class.
Device monitoring is provided by :class:`Monitor` and
:class:`MonitorObserver`. With :mod:`pyudev.pyqt4`, :mod:`pyudev.pyside`,
:mod:`pyudev.glib` and :mod:`pyudev.wx` device monitoring can be integrated
into the event loop of various GUI toolkits.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literals)�
Attributes)�Device)�Devices)�DeviceNotFoundAtPathError)�DeviceNotFoundByFileError)�DeviceNotFoundByNameError)�DeviceNotFoundByNumberError)�DeviceNotFoundError)� DeviceNotFoundInEnvironmentError)�Tags)�DeviceFileHypothesis)�DeviceNameHypothesis)�DeviceNumberHypothesis)�DevicePathHypothesis)� Discovery)�Context)�
Enumerator)�Monitor)�MonitorObserver)� __version__)�__version_info__)� udev_versionN)"�__doc__Z
__future__r r r r Z
pyudev.devicer r r r r
r r r
r r Zpyudev.discoverr r r r r Z pyudev.corer r Zpyudev.monitorr r Zpyudev.versionr r Z pyudev._utilr � r r � /usr/lib/python3.6/__init__.py�<module># s4 __pycache__/_util.cpython-36.pyc 0000644 00000013502 15035142004 0012511 0 ustar 00 3
N�#W( � @ s� d Z ddlmZmZmZmZ yddlmZ W n ek
rL ddl mZ Y nX ddl
Z
ddl Z ddl Z ddl
Z
ddlZdd� Zdd� Zd d
� Zd d � Zd
d� Zdd� Zdd� Zdd� ZdS )z|
pyudev._util
============
Internal utilities
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�print_function�division�unicode_literals�absolute_import)� check_outputNc C s t | t�s| jtj� �} | S )z�
Return the given ``value`` as bytestring.
If the given ``value`` is not a byte string, but a real unicode string, it
is encoded with the filesystem encoding (as in
:func:`sys.getfilesystemencoding()`).
)�
isinstance�bytes�encode�sys�getfilesystemencoding)�value� r
�/usr/lib/python3.6/_util.py�ensure_byte_string- s
r c C s t | tj�s| jtj� �} | S )z�
Return the given ``value`` as unicode string.
If the given ``value`` is not a unicode string, but a byte string, it is
decoded with the filesystem encoding (as in
:func:`sys.getfilesystemencoding()`).
)r �six� text_type�decoder
r )r r
r
r �ensure_unicode_string: s r c C s2 t | t�rt| �} t | t�r | S ttj| ��S dS )a�
Return a byte string, which represents the given ``value`` in a way
suitable as raw value of an udev property.
If ``value`` is a boolean object, it is converted to ``'1'`` or ``'0'``,
depending on whether ``value`` is ``True`` or ``False``. If ``value`` is a
byte string already, it is returned unchanged. Anything else is simply
converted to a unicode string, and then passed to
:func:`ensure_byte_string`.
N)r �bool�intr r r r )r r
r
r �property_value_to_bytesG s
r c C s | dkrt dj| ���| dkS )z�
Convert the given unicode string ``value`` to a boolean object.
If ``value`` is ``'1'``, ``True`` is returned. If ``value`` is ``'0'``,
``False`` is returned. Any other value raises a
:exc:`~exceptions.ValueError`.
�1�0zNot a boolean value: {0!r})r r )�
ValueError�format)r r
r
r �string_to_bool\ s r c c s6 x0|r0| j |�}| j|�}||fV | j|�}qW dS )z�
Iteration helper for udev list entry objects.
Yield a tuple ``(name, value)``. ``name`` and ``value`` are bytestrings
containing the name and the value of the list entry. The exact contents
depend on the list iterated over.
N)Zudev_list_entry_get_nameZudev_list_entry_get_valueZudev_list_entry_get_next)Zlibudev�entry�namer r
r
r �udev_list_iteratei s
r c C s: t j| �j}tj|�rdS tj|�r(dS tdj| ���dS )a�
Get the device type of a device file.
``filename`` is a string containing the path of a device file.
Return ``'char'`` if ``filename`` is a character device, or ``'block'`` if
``filename`` is a block device. Raise :exc:`~exceptions.ValueError` if
``filename`` is no device file at all. Raise
:exc:`~exceptions.EnvironmentError` if ``filename`` does not exist or if
its metadata was inaccessible.
.. versionadded:: 0.15
�char�blockznot a device file: {0!r}N)�os�stat�st_mode�S_ISCHR�S_ISBLKr r )�filename�moder
r
r �get_device_typex s
r( c O sv ddl }xhy
| ||�S tt|jfk
rl } z4t|ttf�rD|j}n
|jd }|tjkrZw
� W Y dd}~X q
X q
W dS )a=
Handle interruptions to an interruptible system call.
Run an interruptible system call in a loop and retry if it raises EINTR.
The signal calls that may raise EINTR prior to Python 3.5 are listed in
PEP 0475. Any calls to these functions must be wrapped in eintr_retry_call
in order to handle EINTR returns in older versions of Python.
This function is safe to use under Python 3.5 and newer since the wrapped
function will simply return without raising EINTR.
This function is based on _eintr_retry_call in python's subprocess.py.
r N)�select�OSError�IOError�errorr �errno�argsZEINTR)�funcr. �kwargsr) �errZ
error_coder
r
r �eintr_retry_call� s
r2 c C s t tddg��} t| j� �S )ak
Get the version of the underlying udev library.
udev doesn't use a standard major-minor versioning scheme, but instead
labels releases with a single consecutive number. Consequently, the
version number returned by this function is a single integer, and not a
tuple (like for instance the interpreter version in
:data:`sys.version_info`).
As libudev itself does not provide a function to query the version number,
this function calls the ``udevadm`` utility, so be prepared to catch
:exc:`~exceptions.EnvironmentError` and
:exc:`~subprocess.CalledProcessError` if you call this function.
Return the version number as single integer. Raise
:exc:`~exceptions.ValueError`, if the version number retrieved from udev
could not be converted to an integer. Raise
:exc:`~exceptions.EnvironmentError`, if ``udevadm`` was not found, or could
not be executed. Raise :exc:`subprocess.CalledProcessError`, if
``udevadm`` returned a non-zero exit code. On Python 2.7 or newer, the
``output`` attribute of this exception is correctly set.
.. versionadded:: 0.8
Zudevadmz --version)r r r �strip)�outputr
r
r � udev_version� s r5 )�__doc__Z
__future__r r r r �
subprocessr � ImportErrorZpyudev._compatr! r
r" r- r r r r r r r( r2 r5 r
r
r
r �<module> s$
! monitor.py 0000644 00000050730 15035142004 0006604 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2010, 2011, 2012, 2013 Sebastian Wiesner <lunaryorn@gmail.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev.monitor
==============
Monitor implementation.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
"""
from __future__ import (print_function, division, unicode_literals,
absolute_import)
import os
import errno
from threading import Thread
from functools import partial
from pyudev.device import Device
from pyudev._util import eintr_retry_call
from pyudev._util import ensure_byte_string
from pyudev._os import pipe
from pyudev._os import poll
class Monitor(object):
"""
A synchronous device event monitor.
A :class:`Monitor` objects connects to the udev daemon and listens for
changes to the device list. A monitor is created by connecting to the
kernel daemon through netlink (see :meth:`from_netlink`):
>>> from pyudev import Context, Monitor
>>> context = Context()
>>> monitor = Monitor.from_netlink(context)
Once the monitor is created, you can add a filter using :meth:`filter_by()`
or :meth:`filter_by_tag()` to drop incoming events in subsystems, which are
not of interest to the application:
>>> monitor.filter_by('input')
When the monitor is eventually set up, you can either poll for events
synchronously:
>>> device = monitor.poll(timeout=3)
>>> if device:
... print('{0.action}: {0}'.format(device))
...
Or you can monitor events asynchronously with :class:`MonitorObserver`.
To integrate into various event processing frameworks, the monitor provides
a :func:`selectable <select.select>` file description by :meth:`fileno()`.
However, do *not* read or write directly on this file descriptor.
Instances of this class can directly be given as ``udev_monitor *`` to
functions wrapped through :mod:`ctypes`.
.. versionchanged:: 0.16
Remove :meth:`from_socket()` which is deprecated, and even removed in
recent udev versions.
"""
def __init__(self, context, monitor_p):
self.context = context
self._as_parameter_ = monitor_p
self._libudev = context._libudev
self._started = False
def __del__(self):
self._libudev.udev_monitor_unref(self)
@classmethod
def from_netlink(cls, context, source='udev'):
"""
Create a monitor by connecting to the kernel daemon through netlink.
``context`` is the :class:`Context` to use. ``source`` is a string,
describing the event source. Two sources are available:
``'udev'`` (the default)
Events emitted after udev as registered and configured the device.
This is the absolutely recommended source for applications.
``'kernel'``
Events emitted directly after the kernel has seen the device. The
device has not yet been configured by udev and might not be usable
at all. **Never** use this, unless you know what you are doing.
Return a new :class:`Monitor` object, which is connected to the
given source. Raise :exc:`~exceptions.ValueError`, if an invalid
source has been specified. Raise
:exc:`~exceptions.EnvironmentError`, if the creation of the monitor
failed.
"""
if source not in ('kernel', 'udev'):
raise ValueError('Invalid source: {0!r}. Must be one of "udev" '
'or "kernel"'.format(source))
monitor = context._libudev.udev_monitor_new_from_netlink(
context, ensure_byte_string(source))
if not monitor:
raise EnvironmentError('Could not create udev monitor')
return cls(context, monitor)
@property
def started(self):
"""
``True``, if this monitor was started, ``False`` otherwise. Readonly.
.. seealso:: :meth:`start()`
.. versionadded:: 0.16
"""
return self._started
def fileno(self):
# pylint: disable=anomalous-backslash-in-string
"""
Return the file description associated with this monitor as integer.
This is really a real file descriptor ;), which can be watched and
:func:`select.select`\ ed.
"""
return self._libudev.udev_monitor_get_fd(self)
def filter_by(self, subsystem, device_type=None):
"""
Filter incoming events.
``subsystem`` is a byte or unicode string with the name of a
subsystem (e.g. ``'input'``). Only events originating from the
given subsystem pass the filter and are handed to the caller.
If given, ``device_type`` is a byte or unicode string specifying the
device type. Only devices with the given device type are propagated
to the caller. If ``device_type`` is not given, no additional
filter for a specific device type is installed.
These filters are executed inside the kernel, and client processes
will usually not be woken up for device, that do not match these
filters.
.. versionchanged:: 0.15
This method can also be after :meth:`start()` now.
"""
subsystem = ensure_byte_string(subsystem)
if device_type is not None:
device_type = ensure_byte_string(device_type)
self._libudev.udev_monitor_filter_add_match_subsystem_devtype(
self, subsystem, device_type)
self._libudev.udev_monitor_filter_update(self)
def filter_by_tag(self, tag):
"""
Filter incoming events by the given ``tag``.
``tag`` is a byte or unicode string with the name of a tag. Only
events for devices which have this tag attached pass the filter and are
handed to the caller.
Like with :meth:`filter_by` this filter is also executed inside the
kernel, so that client processes are usually not woken up for devices
without the given ``tag``.
.. udevversion:: 154
.. versionadded:: 0.9
.. versionchanged:: 0.15
This method can also be after :meth:`start()` now.
"""
self._libudev.udev_monitor_filter_add_match_tag(
self, ensure_byte_string(tag))
self._libudev.udev_monitor_filter_update(self)
def remove_filter(self):
"""
Remove any filters installed with :meth:`filter_by()` or
:meth:`filter_by_tag()` from this monitor.
.. warning::
Up to udev 181 (and possibly even later versions) the underlying
``udev_monitor_filter_remove()`` seems to be broken. If used with
affected versions this method always raises
:exc:`~exceptions.ValueError`.
Raise :exc:`~exceptions.EnvironmentError` if removal of installed
filters failed.
.. versionadded:: 0.15
"""
self._libudev.udev_monitor_filter_remove(self)
self._libudev.udev_monitor_filter_update(self)
def enable_receiving(self):
"""
Switch the monitor into listing mode.
Connect to the event source and receive incoming events. Only after
calling this method, the monitor listens for incoming events.
.. note::
This method is implicitly called by :meth:`__iter__`. You don't
need to call it explicitly, if you are iterating over the
monitor.
.. deprecated:: 0.16
Will be removed in 1.0. Use :meth:`start()` instead.
"""
import warnings
warnings.warn('Will be removed in 1.0. Use Monitor.start() instead.',
DeprecationWarning)
self.start()
def start(self):
"""
Start this monitor.
The monitor will not receive events until this method is called. This
method does nothing if called on an already started :class:`Monitor`.
.. note::
Typically you don't need to call this method. It is implicitly
called by :meth:`poll()` and :meth:`__iter__()`.
.. seealso:: :attr:`started`
.. versionchanged:: 0.16
This method does nothing if the :class:`Monitor` was already
started.
"""
if not self._started:
self._libudev.udev_monitor_enable_receiving(self)
# Force monitor FD into non-blocking mode
pipe.set_fd_status_flag(self, os.O_NONBLOCK)
self._started = True
def set_receive_buffer_size(self, size):
"""
Set the receive buffer ``size``.
``size`` is the requested buffer size in bytes, as integer.
.. note::
The CAP_NET_ADMIN capability must be contained in the effective
capability set of the caller for this method to succeed. Otherwise
:exc:`~exceptions.EnvironmentError` will be raised, with ``errno``
set to :data:`~errno.EPERM`. Unprivileged processes typically lack
this capability. You can check the capabilities of the current
process with the python-prctl_ module:
>>> import prctl
>>> prctl.cap_effective.net_admin
Raise :exc:`~exceptions.EnvironmentError`, if the buffer size could not
bet set.
.. versionadded:: 0.13
.. _python-prctl: http://packages.python.org/python-prctl
"""
self._libudev.udev_monitor_set_receive_buffer_size(self, size)
def _receive_device(self):
"""Receive a single device from the monitor.
Return the received :class:`Device`, or ``None`` if no device could be
received.
"""
while True:
try:
device_p = self._libudev.udev_monitor_receive_device(self)
return Device(self.context, device_p) if device_p else None
except EnvironmentError as error:
if error.errno in (errno.EAGAIN, errno.EWOULDBLOCK):
# No data available
return None
elif error.errno == errno.EINTR:
# Try again if our system call was interrupted
continue
else:
raise
def poll(self, timeout=None):
"""
Poll for a device event.
You can use this method together with :func:`iter()` to synchronously
monitor events in the current thread::
for device in iter(monitor.poll, None):
print('{0.action} on {0.device_path}'.format(device))
Since this method will never return ``None`` if no ``timeout`` is
specified, this is effectively an endless loop. With
:func:`functools.partial()` you can also create a loop that only waits
for a specified time::
for device in iter(partial(monitor.poll, 3), None):
print('{0.action} on {0.device_path}'.format(device))
This loop will only wait three seconds for a new device event. If no
device event occurred after three seconds, the loop will exit.
``timeout`` is a floating point number that specifies a time-out in
seconds. If omitted or ``None``, this method blocks until a device
event is available. If ``0``, this method just polls and will never
block.
.. note::
This method implicitly calls :meth:`start()`.
Return the received :class:`Device`, or ``None`` if a timeout
occurred. Raise :exc:`~exceptions.EnvironmentError` if event retrieval
failed.
.. seealso::
:attr:`Device.action`
The action that created this event.
:attr:`Device.sequence_number`
The sequence number of this event.
.. versionadded:: 0.16
"""
if timeout is not None and timeout > 0:
# .poll() takes timeout in milliseconds
timeout = int(timeout * 1000)
self.start()
if eintr_retry_call(poll.Poll.for_events((self, 'r')).poll, timeout):
return self._receive_device()
else:
return None
def receive_device(self):
"""
Receive a single device from the monitor.
.. warning::
You *must* call :meth:`start()` before calling this method.
The caller must make sure, that there are events available in the
event queue. The call blocks, until a device is available.
If a device was available, return ``(action, device)``. ``device``
is the :class:`Device` object describing the device. ``action`` is
a string describing the action. Usual actions are:
``'add'``
A device has been added (e.g. a USB device was plugged in)
``'remove'``
A device has been removed (e.g. a USB device was unplugged)
``'change'``
Something about the device changed (e.g. a device property)
``'online'``
The device is online now
``'offline'``
The device is offline now
Raise :exc:`~exceptions.EnvironmentError`, if no device could be
read.
.. deprecated:: 0.16
Will be removed in 1.0. Use :meth:`Monitor.poll()` instead.
"""
import warnings
warnings.warn('Will be removed in 1.0. Use Monitor.poll() instead.',
DeprecationWarning)
device = self.poll()
return device.action, device
def __iter__(self):
"""
Wait for incoming events and receive them upon arrival.
This methods implicitly calls :meth:`start()`, and starts polling the
:meth:`fileno` of this monitor. If a event comes in, it receives the
corresponding device and yields it to the caller.
The returned iterator is endless, and continues receiving devices
without ever stopping.
Yields ``(action, device)`` (see :meth:`receive_device` for a
description).
.. deprecated:: 0.16
Will be removed in 1.0. Use an explicit loop over :meth:`poll()`
instead, or monitor asynchronously with :class:`MonitorObserver`.
"""
import warnings
warnings.warn('Will be removed in 1.0. Use an explicit loop over '
'"poll()" instead, or monitor asynchronously with '
'"MonitorObserver".', DeprecationWarning)
self.start()
while True:
device = self.poll()
if device is not None:
yield device.action, device
class MonitorObserver(Thread):
"""
An asynchronous observer for device events.
This class subclasses :class:`~threading.Thread` class to asynchronously
observe a :class:`Monitor` in a background thread:
>>> from pyudev import Context, Monitor, MonitorObserver
>>> context = Context()
>>> monitor = Monitor.from_netlink(context)
>>> monitor.filter_by(subsystem='input')
>>> def print_device_event(device):
... print('background event {0.action}: {0.device_path}'.format(device))
>>> observer = MonitorObserver(monitor, callback=print_device_event, name='monitor-observer')
>>> observer.daemon
True
>>> observer.start()
In the above example, input device events will be printed in background,
until :meth:`stop()` is called on ``observer``.
.. note::
Instances of this class are always created as daemon thread. If you do
not want to use daemon threads for monitoring, you need explicitly set
:attr:`~threading.Thread.daemon` to ``False`` before invoking
:meth:`~threading.Thread.start()`.
.. seealso::
:attr:`Device.action`
The action that created this event.
:attr:`Device.sequence_number`
The sequence number of this event.
.. versionadded:: 0.14
.. versionchanged:: 0.15
:meth:`Monitor.start()` is implicitly called when the thread is started.
"""
def __init__(self, monitor, event_handler=None, callback=None, *args,
**kwargs):
"""
Create a new observer for the given ``monitor``.
``monitor`` is the :class:`Monitor` to observe. ``callback`` is the
callable to invoke on events, with the signature ``callback(device)``
where ``device`` is the :class:`Device` that caused the event.
.. warning::
``callback`` is invoked in the observer thread, hence the observer
is blocked while callback executes.
``args`` and ``kwargs`` are passed unchanged to the constructor of
:class:`~threading.Thread`.
.. deprecated:: 0.16
The ``event_handler`` argument will be removed in 1.0. Use
the ``callback`` argument instead.
.. versionchanged:: 0.16
Add ``callback`` argument.
"""
if callback is None and event_handler is None:
raise ValueError('callback missing')
elif callback is not None and event_handler is not None:
raise ValueError('Use either callback or event handler')
Thread.__init__(self, *args, **kwargs)
self.monitor = monitor
# observer threads should not keep the interpreter alive
self.daemon = True
self._stop_event = None
if event_handler is not None:
import warnings
warnings.warn('"event_handler" argument will be removed in 1.0. '
'Use Monitor.poll() instead.', DeprecationWarning)
callback = lambda d: event_handler(d.action, d)
self._callback = callback
def start(self):
"""Start the observer thread."""
if not self.is_alive():
self._stop_event = pipe.Pipe.open()
Thread.start(self)
def run(self):
self.monitor.start()
notifier = poll.Poll.for_events(
(self.monitor, 'r'), (self._stop_event.source, 'r'))
while True:
for file_descriptor, event in eintr_retry_call(notifier.poll):
if file_descriptor == self._stop_event.source.fileno():
# in case of a stop event, close our pipe side, and
# return from the thread
self._stop_event.source.close()
return
elif file_descriptor == self.monitor.fileno() and event == 'r':
read_device = partial(eintr_retry_call, self.monitor.poll, timeout=0)
for device in iter(read_device, None):
self._callback(device)
else:
raise EnvironmentError('Observed monitor hung up')
def send_stop(self):
"""
Send a stop signal to the background thread.
The background thread will eventually exit, but it may still be running
when this method returns. This method is essentially the asynchronous
equivalent to :meth:`stop()`.
.. note::
The underlying :attr:`monitor` is *not* stopped.
"""
if self._stop_event is None:
return
with self._stop_event.sink:
# emit a stop event to the thread
eintr_retry_call(self._stop_event.sink.write, b'\x01')
self._stop_event.sink.flush()
def stop(self):
"""
Synchronously stop the background thread.
.. note::
This method can safely be called from the observer thread. In this
case it is equivalent to :meth:`send_stop()`.
Send a stop signal to the backgroud (see :meth:`send_stop`), and waits
for the background thread to exit (see :meth:`~threading.Thread.join`)
if the current thread is *not* the observer thread.
After this method returns in a thread *that is not the observer
thread*, the ``callback`` is guaranteed to not be invoked again
anymore.
.. note::
The underlying :attr:`monitor` is *not* stopped.
.. versionchanged:: 0.16
This method can be called from the observer thread.
"""
self.send_stop()
try:
self.join()
except RuntimeError:
pass
_ctypeslib/__init__.py 0000644 00000001717 15035142004 0011012 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2015 mulhern <amulhern@redhat.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev._ctypeslib
=================
Wrappers for libraries.
.. moduleauthor:: mulhern <amulhern@redhat.com>
"""
from . import libc
from . import libudev
_ctypeslib/__pycache__/_errorcheckers.cpython-36.opt-1.pyc 0000644 00000004555 15035142004 0017501 0 ustar 00 3
u1�W� � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlZddlm Z ej
e ej e
ejeiZdd � Zd
d � Zd d
� Zdd� ZdS )zt
pyudev._ctypeslib._errorcheckers
================================
Error checkers for ctypes wrappers.
� )�absolute_import)�division)�print_function)�unicode_literalsN)� get_errnoc C s2 t j| �}tj| �}|dk r$||�S t| |�S dS )z�Create an exception from ``errnum``.
``errnum`` is an integral error number.
Return an exception object appropriate to ``errnum``.
N)�ERRNO_EXCEPTIONS�get�os�strerror�EnvironmentError)�errnumZ exceptionZerrorstr� r
�$/usr/lib/python3.6/_errorcheckers.py�exception_from_errno+ s
r c G s | dk r| }t |��n| S dS )a� Error checker for funtions, which return negative error codes.
If ``result`` is smaller than ``0``, it is interpreted as negative error
code, and an appropriate exception is raised:
- ``-ENOMEM`` raises a :exc:`~exceptions.MemoryError`
- ``-EOVERFLOW`` raises a :exc:`~exceptions.OverflowError`
- all other error codes raise :exc:`~exceptions.EnvironmentError`
If result is greater or equal to ``0``, it is returned unchanged.
r N)r )�result�func�argsr r
r
r �check_negative_errorcode; s
r c G s" | dkr t � }|dkr t|��| S )z�Error checker to check the system ``errno`` as returned by
:func:`ctypes.get_errno()`.
If ``result`` is not ``0``, an exception according to this errno is raised.
Otherwise nothing happens.
r )r r )r r r r r
r
r � check_errno_on_nonzero_returnP s
r c G s | st � }|dkrt|��| S )z�Error checker to check the system ``errno`` as returned by
:func:`ctypes.get_errno()`.
If ``result`` is a null pointer, an exception according to this errno is
raised. Otherwise nothing happens.
r )r r )r r r r r
r
r �"check_errno_on_null_pointer_return_ s
r )�__doc__Z
__future__r r r r r �errnoZctypesr ZENOMEM� MemoryErrorZ EOVERFLOW�
OverflowErrorZEINVAL�
ValueErrorr r r r r r
r
r
r �<module> s
_ctypeslib/__pycache__/libc.cpython-36.opt-1.pyc 0000644 00000001177 15035142004 0015407 0 ustar 00 3
u1�W< � @ st d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ed Z
e e
egefd
�Z e e d
�Z
d S ) z�
pyudev._ctypeslib.libc
======================
Wrappers for libc.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literals)�c_int� )� check_errno_on_nonzero_return� )�pipe2N)�__doc__Z
__future__r r r r Zctypesr Z_errorcheckersr Zfd_pair�dictZ
SIGNATURESZERROR_CHECKERS� r
r
�/usr/lib/python3.6/libc.py�<module> s _ctypeslib/__pycache__/utils.cpython-36.opt-1.pyc 0000644 00000003126 15035142004 0015632 0 ustar 00 3
u1�W� � @ sX d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z dd � Z
d
S ) z�
pyudev._ctypeslib.utils
=======================
Utilities for loading ctypeslib.
.. moduleauthor:: Anne Mulhern <amulhern@redhat.com>
� )�absolute_import)�division)�print_function)�unicode_literals)�CDLL)� find_libraryc C sv t | �}|std| ��t|dd�}xL|j� D ]@\}}t||d�}|r.|\}} ||_| |_|j|�}
|
r.|
|_q.W |S )a{
Load library ``name`` and return a :class:`ctypes.CDLL` object for it.
:param str name: the library name
:param signatures: signatures of methods
:type signatures: dict of str * (tuple of (list of type) * type)
:param error_checkers: error checkers for methods
:type error_checkers: dict of str * ((int * ptr * arglist) -> int)
The library has errno handling enabled.
Important functions are given proper signatures and return types to support
type checking and argument conversion.
:returns: a loaded library
:rtype: ctypes.CDLL
:raises ImportError: if the library is not found
zNo library named %sT)Z use_errnoN) r � ImportErrorr �items�getattr�argtypes�restype�getZerrcheck) �nameZ
signaturesZerror_checkersZ library_name�lib�funcnameZ signatureZfunctionr r Z errorchecker� r �/usr/lib/python3.6/utils.py�load_ctypes_library$ s
r N) �__doc__Z
__future__r r r r Zctypesr Z ctypes.utilr r r r r r �<module> s _ctypeslib/__pycache__/libc.cpython-36.pyc 0000644 00000001177 15035142004 0014450 0 ustar 00 3
u1�W< � @ st d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ed Z
e e
egefd
�Z e e d
�Z
d S ) z�
pyudev._ctypeslib.libc
======================
Wrappers for libc.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literals)�c_int� )� check_errno_on_nonzero_return� )�pipe2N)�__doc__Z
__future__r r r r Zctypesr Z_errorcheckersr Zfd_pair�dictZ
SIGNATURESZERROR_CHECKERS� r
r
�/usr/lib/python3.6/libc.py�<module> s _ctypeslib/__pycache__/libudev.cpython-36.opt-1.pyc 0000644 00000013134 15035142004 0016124 0 ustar 00 3
u1�W+* � I @ sf d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z dd lm
Z
dd
lm Z dd lm Z dd lm
Z
dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ G dd� de
�Zee�ZG dd� de
�Zee�ZG dd� de
�Zee�ZG dd� de
�Zee�Z G dd � d e
�Z ee �Z G d d � d e
�Z ee �Z e Z!e"g efegd fegefegefegefegefege fee gd fegefegefegd feege feege feeege feeege feeege feege feege fee ge fege fege fegefegefegefegefe ge fe gd feege feeege feee!ge feege fege fe ge fe eege fe gefe gefe gefe gefe gefe gefe gefe gefe egefe egefe ge!fe gefe ge fe ge fe ge fe gefe gefe gefe gefe eege fe ege fe ge fe gd feege fe ge fe e ge fe ge fe ge fe eege fe ege fe ge fe ge fe ge fe gd fege fe ee
gefd �FZ#e"d d d d d d d d d d d d d d d d d d d d d d d d d d d d d eeeeeeeeeed d d d d d d d d d d d d d d d eeed eeeed d d d d d d d!�FZ$d S )"z�
pyudev._ctypeslib.libudev
=========================
Wrapper types for libudev. Use ``libudev`` attribute to access libudev
functions.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literals)�c_char)�c_char_p)�c_int)�c_uint)� c_ulonglong)�CDLL)� Structure)�POINTER)� find_library� )� check_errno_on_nonzero_return)�"check_errno_on_null_pointer_return)�check_negative_errorcodec @ s e Zd ZdZdS )�udevz'
Dummy for ``udev`` structure.
N)�__name__�
__module__� __qualname__�__doc__� r r � /usr/lib/python3.6/libudev.pyr 2 s r c @ s e Zd ZdZdS )�udev_enumeratez1
Dummy for ``udev_enumerate`` structure.
N)r r r r r r r r r < s r c @ s e Zd ZdZdS )�udev_list_entryz2
Dummy for ``udev_list_entry`` structure.
N)r r r r r r r r r F s r c @ s e Zd ZdZdS )� udev_devicez.
Dummy for ``udev_device`` structure.
N)r r r r r r r r r P s r c @ s e Zd ZdZdS )� udev_monitorz.
Dummy for ``udev_device`` structure.
N)r r r r r r r r r Z s r c @ s e Zd ZdZdS )� udev_hwdbz,
Dummy for ``udev_hwdb`` structure.
N)r r r r r r r r r c s r N)F�udev_new�
udev_unref�udev_ref�udev_get_sys_path�udev_get_dev_path�udev_get_run_path�udev_get_log_priority�udev_set_log_priority�udev_enumerate_new�udev_enumerate_ref�udev_enumerate_unref�"udev_enumerate_add_match_subsystem�$udev_enumerate_add_nomatch_subsystem�!udev_enumerate_add_match_property� udev_enumerate_add_match_sysattr�"udev_enumerate_add_nomatch_sysattr� udev_enumerate_add_match_tag� udev_enumerate_add_match_sysname� udev_enumerate_add_match_parent�'udev_enumerate_add_match_is_initialized�udev_enumerate_scan_devices� udev_enumerate_get_list_entry�udev_list_entry_get_next�udev_list_entry_get_name�udev_list_entry_get_value�udev_device_ref�udev_device_unref� udev_device_new_from_syspath�&udev_device_new_from_subsystem_sysname�udev_device_new_from_devnum� udev_device_new_from_device_id� udev_device_new_from_environment�udev_device_get_parent�-udev_device_get_parent_with_subsystem_devtype�udev_device_get_devpath�udev_device_get_subsystem�udev_device_get_syspath�udev_device_get_sysnum�udev_device_get_sysname�udev_device_get_driver�udev_device_get_devtype�udev_device_get_devnode� udev_device_get_property_value� udev_device_get_sysattr_value�udev_device_get_devnum�udev_device_get_action�udev_device_get_seqnum� udev_device_get_is_initialized�&udev_device_get_usec_since_initialized�#udev_device_get_devlinks_list_entry� udev_device_get_tags_list_entry�%udev_device_get_properties_list_entry�"udev_device_get_sysattr_list_entry� udev_device_set_sysattr_value�udev_device_has_tag�udev_monitor_ref�udev_monitor_unref� udev_monitor_new_from_netlink� udev_monitor_enable_receiving�$udev_monitor_set_receive_buffer_size�udev_monitor_get_fd�udev_monitor_receive_device�/udev_monitor_filter_add_match_subsystem_devtype�!udev_monitor_filter_add_match_tag�udev_monitor_filter_update�udev_monitor_filter_remove�
udev_hwdb_ref�udev_hwdb_unref�
udev_hwdb_new�#udev_hwdb_get_properties_list_entry)FrL rP rH rK rA rG rF rN r? r@ rR rI rM rB rS rJ rE rD rC rQ rO rU r= r< r> r; r: r8 r9 rT r1 r* r+ r, r- r. r/ r0 r2 r4 r' r( r3 r) r# r% r$ r" rd rc ra rb r6 r5 r7 rZ rY r\ rV r] r^ r_ r` r[ rX rW r r! r& r )%r Z
__future__r r r r Zctypesr r r r r
r r r
Z ctypes.utilr Z_errorcheckersr r r r Zudev_pr Zudev_enumerate_pr Zudev_list_entry_pr Z
udev_device_pr Zudev_monitor_pr Z udev_hwdb_pZdev_t�dictZ
SIGNATURESZERROR_CHECKERSr r r r �<module> sb
_ctypeslib/__pycache__/__init__.cpython-36.pyc 0000644 00000000476 15035142004 0015277 0 ustar 00 3
H�V� � @ s d Z ddlmZ ddlmZ dS )z�
pyudev._ctypeslib
=================
Wrappers for libraries.
.. moduleauthor:: mulhern <amulhern@redhat.com>
� )�libc)�libudevN)�__doc__� r r � r r � /usr/lib/python3.6/__init__.py�<module> s _ctypeslib/__pycache__/__init__.cpython-36.opt-1.pyc 0000644 00000000476 15035142004 0016236 0 ustar 00 3
H�V� � @ s d Z ddlmZ ddlmZ dS )z�
pyudev._ctypeslib
=================
Wrappers for libraries.
.. moduleauthor:: mulhern <amulhern@redhat.com>
� )�libc)�libudevN)�__doc__� r r � r r � /usr/lib/python3.6/__init__.py�<module> s _ctypeslib/__pycache__/libudev.cpython-36.pyc 0000644 00000013134 15035142004 0015165 0 ustar 00 3
u1�W+* � I @ sf d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z dd lm
Z
dd
lm Z dd lm Z dd lm
Z
dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ G dd� de
�Zee�ZG dd� de
�Zee�ZG dd� de
�Zee�ZG dd� de
�Zee�Z G dd � d e
�Z ee �Z G d d � d e
�Z ee �Z e Z!e"g efegd fegefegefegefegefege fee gd fegefegefegd feege feege feeege feeege feeege feege feege fee ge fege fege fegefegefegefegefe ge fe gd feege feeege feee!ge feege fege fe ge fe eege fe gefe gefe gefe gefe gefe gefe gefe gefe egefe egefe ge!fe gefe ge fe ge fe ge fe gefe gefe gefe gefe eege fe ege fe ge fe gd feege fe ge fe e ge fe ge fe ge fe eege fe ege fe ge fe ge fe ge fe gd fege fe ee
gefd �FZ#e"d d d d d d d d d d d d d d d d d d d d d d d d d d d d d eeeeeeeeeed d d d d d d d d d d d d d d d eeed eeeed d d d d d d d!�FZ$d S )"z�
pyudev._ctypeslib.libudev
=========================
Wrapper types for libudev. Use ``libudev`` attribute to access libudev
functions.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literals)�c_char)�c_char_p)�c_int)�c_uint)� c_ulonglong)�CDLL)� Structure)�POINTER)� find_library� )� check_errno_on_nonzero_return)�"check_errno_on_null_pointer_return)�check_negative_errorcodec @ s e Zd ZdZdS )�udevz'
Dummy for ``udev`` structure.
N)�__name__�
__module__� __qualname__�__doc__� r r � /usr/lib/python3.6/libudev.pyr 2 s r c @ s e Zd ZdZdS )�udev_enumeratez1
Dummy for ``udev_enumerate`` structure.
N)r r r r r r r r r < s r c @ s e Zd ZdZdS )�udev_list_entryz2
Dummy for ``udev_list_entry`` structure.
N)r r r r r r r r r F s r c @ s e Zd ZdZdS )� udev_devicez.
Dummy for ``udev_device`` structure.
N)r r r r r r r r r P s r c @ s e Zd ZdZdS )� udev_monitorz.
Dummy for ``udev_device`` structure.
N)r r r r r r r r r Z s r c @ s e Zd ZdZdS )� udev_hwdbz,
Dummy for ``udev_hwdb`` structure.
N)r r r r r r r r r c s r N)F�udev_new�
udev_unref�udev_ref�udev_get_sys_path�udev_get_dev_path�udev_get_run_path�udev_get_log_priority�udev_set_log_priority�udev_enumerate_new�udev_enumerate_ref�udev_enumerate_unref�"udev_enumerate_add_match_subsystem�$udev_enumerate_add_nomatch_subsystem�!udev_enumerate_add_match_property� udev_enumerate_add_match_sysattr�"udev_enumerate_add_nomatch_sysattr� udev_enumerate_add_match_tag� udev_enumerate_add_match_sysname� udev_enumerate_add_match_parent�'udev_enumerate_add_match_is_initialized�udev_enumerate_scan_devices� udev_enumerate_get_list_entry�udev_list_entry_get_next�udev_list_entry_get_name�udev_list_entry_get_value�udev_device_ref�udev_device_unref� udev_device_new_from_syspath�&udev_device_new_from_subsystem_sysname�udev_device_new_from_devnum� udev_device_new_from_device_id� udev_device_new_from_environment�udev_device_get_parent�-udev_device_get_parent_with_subsystem_devtype�udev_device_get_devpath�udev_device_get_subsystem�udev_device_get_syspath�udev_device_get_sysnum�udev_device_get_sysname�udev_device_get_driver�udev_device_get_devtype�udev_device_get_devnode� udev_device_get_property_value� udev_device_get_sysattr_value�udev_device_get_devnum�udev_device_get_action�udev_device_get_seqnum� udev_device_get_is_initialized�&udev_device_get_usec_since_initialized�#udev_device_get_devlinks_list_entry� udev_device_get_tags_list_entry�%udev_device_get_properties_list_entry�"udev_device_get_sysattr_list_entry� udev_device_set_sysattr_value�udev_device_has_tag�udev_monitor_ref�udev_monitor_unref� udev_monitor_new_from_netlink� udev_monitor_enable_receiving�$udev_monitor_set_receive_buffer_size�udev_monitor_get_fd�udev_monitor_receive_device�/udev_monitor_filter_add_match_subsystem_devtype�!udev_monitor_filter_add_match_tag�udev_monitor_filter_update�udev_monitor_filter_remove�
udev_hwdb_ref�udev_hwdb_unref�
udev_hwdb_new�#udev_hwdb_get_properties_list_entry)FrL rP rH rK rA rG rF rN r? r@ rR rI rM rB rS rJ rE rD rC rQ rO rU r= r< r> r; r: r8 r9 rT r1 r* r+ r, r- r. r/ r0 r2 r4 r' r( r3 r) r# r% r$ r" rd rc ra rb r6 r5 r7 rZ rY r\ rV r] r^ r_ r` r[ rX rW r r! r& r )%r Z
__future__r r r r Zctypesr r r r r
r r r
Z ctypes.utilr Z_errorcheckersr r r r Zudev_pr Zudev_enumerate_pr Zudev_list_entry_pr Z
udev_device_pr Zudev_monitor_pr Z udev_hwdb_pZdev_t�dictZ
SIGNATURESZERROR_CHECKERSr r r r �<module> sb
_ctypeslib/__pycache__/_errorcheckers.cpython-36.pyc 0000644 00000004555 15035142004 0016542 0 ustar 00 3
u1�W� � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlZddlm Z ej
e ej e
ejeiZdd � Zd
d � Zd d
� Zdd� ZdS )zt
pyudev._ctypeslib._errorcheckers
================================
Error checkers for ctypes wrappers.
� )�absolute_import)�division)�print_function)�unicode_literalsN)� get_errnoc C s2 t j| �}tj| �}|dk r$||�S t| |�S dS )z�Create an exception from ``errnum``.
``errnum`` is an integral error number.
Return an exception object appropriate to ``errnum``.
N)�ERRNO_EXCEPTIONS�get�os�strerror�EnvironmentError)�errnumZ exceptionZerrorstr� r
�$/usr/lib/python3.6/_errorcheckers.py�exception_from_errno+ s
r c G s | dk r| }t |��n| S dS )a� Error checker for funtions, which return negative error codes.
If ``result`` is smaller than ``0``, it is interpreted as negative error
code, and an appropriate exception is raised:
- ``-ENOMEM`` raises a :exc:`~exceptions.MemoryError`
- ``-EOVERFLOW`` raises a :exc:`~exceptions.OverflowError`
- all other error codes raise :exc:`~exceptions.EnvironmentError`
If result is greater or equal to ``0``, it is returned unchanged.
r N)r )�result�func�argsr r
r
r �check_negative_errorcode; s
r c G s" | dkr t � }|dkr t|��| S )z�Error checker to check the system ``errno`` as returned by
:func:`ctypes.get_errno()`.
If ``result`` is not ``0``, an exception according to this errno is raised.
Otherwise nothing happens.
r )r r )r r r r r
r
r � check_errno_on_nonzero_returnP s
r c G s | st � }|dkrt|��| S )z�Error checker to check the system ``errno`` as returned by
:func:`ctypes.get_errno()`.
If ``result`` is a null pointer, an exception according to this errno is
raised. Otherwise nothing happens.
r )r r )r r r r r
r
r �"check_errno_on_null_pointer_return_ s
r )�__doc__Z
__future__r r r r r �errnoZctypesr ZENOMEM� MemoryErrorZ EOVERFLOW�
OverflowErrorZEINVAL�
ValueErrorr r r r r r
r
r
r �<module> s
_ctypeslib/__pycache__/utils.cpython-36.pyc 0000644 00000003126 15035142004 0014673 0 ustar 00 3
u1�W� � @ sX d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z dd � Z
d
S ) z�
pyudev._ctypeslib.utils
=======================
Utilities for loading ctypeslib.
.. moduleauthor:: Anne Mulhern <amulhern@redhat.com>
� )�absolute_import)�division)�print_function)�unicode_literals)�CDLL)� find_libraryc C sv t | �}|std| ��t|dd�}xL|j� D ]@\}}t||d�}|r.|\}} ||_| |_|j|�}
|
r.|
|_q.W |S )a{
Load library ``name`` and return a :class:`ctypes.CDLL` object for it.
:param str name: the library name
:param signatures: signatures of methods
:type signatures: dict of str * (tuple of (list of type) * type)
:param error_checkers: error checkers for methods
:type error_checkers: dict of str * ((int * ptr * arglist) -> int)
The library has errno handling enabled.
Important functions are given proper signatures and return types to support
type checking and argument conversion.
:returns: a loaded library
:rtype: ctypes.CDLL
:raises ImportError: if the library is not found
zNo library named %sT)Z use_errnoN) r � ImportErrorr �items�getattr�argtypes�restype�getZerrcheck) �nameZ
signaturesZerror_checkersZ library_name�lib�funcnameZ signatureZfunctionr r Z errorchecker� r �/usr/lib/python3.6/utils.py�load_ctypes_library$ s
r N) �__doc__Z
__future__r r r r Zctypesr Z ctypes.utilr r r r r r �<module> s _ctypeslib/libudev.py 0000644 00000025053 15035142004 0010704 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2010, 2011, 2012, 2013 Sebastian Wiesner <lunaryorn@gmail.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev._ctypeslib.libudev
=========================
Wrapper types for libudev. Use ``libudev`` attribute to access libudev
functions.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from ctypes import c_char
from ctypes import c_char_p
from ctypes import c_int
from ctypes import c_uint
from ctypes import c_ulonglong
from ctypes import CDLL
from ctypes import Structure
from ctypes import POINTER
from ctypes.util import find_library
from ._errorcheckers import check_errno_on_nonzero_return
from ._errorcheckers import check_errno_on_null_pointer_return
from ._errorcheckers import check_negative_errorcode
class udev(Structure): # pylint: disable=invalid-name
"""
Dummy for ``udev`` structure.
"""
# pylint: disable=too-few-public-methods
pass
udev_p = POINTER(udev) # pylint: disable=invalid-name
class udev_enumerate(Structure): # pylint: disable=invalid-name
"""
Dummy for ``udev_enumerate`` structure.
"""
# pylint: disable=too-few-public-methods
pass
udev_enumerate_p = POINTER(udev_enumerate) # pylint: disable=invalid-name
class udev_list_entry(Structure): # pylint: disable=invalid-name
"""
Dummy for ``udev_list_entry`` structure.
"""
# pylint: disable=too-few-public-methods
pass
udev_list_entry_p = POINTER(udev_list_entry) # pylint: disable=invalid-name
class udev_device(Structure): # pylint: disable=invalid-name
"""
Dummy for ``udev_device`` structure.
"""
# pylint: disable=too-few-public-methods
pass
udev_device_p = POINTER(udev_device) # pylint: disable=invalid-name
class udev_monitor(Structure): # pylint: disable=invalid-name
"""
Dummy for ``udev_device`` structure.
"""
# pylint: disable=too-few-public-methods
pass
udev_monitor_p = POINTER(udev_monitor) # pylint: disable=invalid-name
class udev_hwdb(Structure): # pylint: disable=invalid-name
"""
Dummy for ``udev_hwdb`` structure.
"""
# pylint: disable=too-few-public-methods
pass
udev_hwdb_p = POINTER(udev_hwdb) # pylint: disable=invalid-name
dev_t = c_ulonglong # pylint: disable=invalid-name
SIGNATURES = dict(
# context
udev_new=([], udev_p),
udev_unref=([udev_p], None),
udev_ref=([udev_p], udev_p),
udev_get_sys_path=([udev_p], c_char_p),
udev_get_dev_path=([udev_p], c_char_p),
udev_get_run_path=([udev_p], c_char_p),
udev_get_log_priority=([udev_p], c_int),
udev_set_log_priority=([udev_p, c_int], None),
udev_enumerate_new=([udev_p], udev_enumerate_p),
udev_enumerate_ref=([udev_enumerate_p], udev_enumerate_p),
udev_enumerate_unref=([udev_enumerate_p], None),
udev_enumerate_add_match_subsystem=([udev_enumerate_p, c_char_p], c_int),
udev_enumerate_add_nomatch_subsystem=([udev_enumerate_p, c_char_p], c_int),
udev_enumerate_add_match_property=(
[udev_enumerate_p, c_char_p, c_char_p],
c_int
),
udev_enumerate_add_match_sysattr=(
[udev_enumerate_p, c_char_p, c_char_p],
c_int
),
udev_enumerate_add_nomatch_sysattr=(
[udev_enumerate_p, c_char_p, c_char_p],
c_int
),
udev_enumerate_add_match_tag=([udev_enumerate_p, c_char_p], c_int),
udev_enumerate_add_match_sysname=([udev_enumerate_p, c_char_p], c_int),
udev_enumerate_add_match_parent=([udev_enumerate_p, udev_device_p], c_int),
udev_enumerate_add_match_is_initialized=([udev_enumerate_p], c_int),
udev_enumerate_scan_devices=([udev_enumerate_p], c_int),
udev_enumerate_get_list_entry=([udev_enumerate_p], udev_list_entry_p),
# list entries
udev_list_entry_get_next=([udev_list_entry_p], udev_list_entry_p),
udev_list_entry_get_name=([udev_list_entry_p], c_char_p),
udev_list_entry_get_value=([udev_list_entry_p], c_char_p),
# devices
udev_device_ref=([udev_device_p], udev_device_p),
udev_device_unref=([udev_device_p], None),
udev_device_new_from_syspath=([udev_p, c_char_p], udev_device_p),
udev_device_new_from_subsystem_sysname=(
[udev_p, c_char_p, c_char_p],
udev_device_p
),
udev_device_new_from_devnum=([udev_p, c_char, dev_t], udev_device_p),
udev_device_new_from_device_id=([udev_p, c_char_p], udev_device_p),
udev_device_new_from_environment=([udev_p], udev_device_p),
udev_device_get_parent=([udev_device_p], udev_device_p),
udev_device_get_parent_with_subsystem_devtype=(
[udev_device_p, c_char_p, c_char_p],
udev_device_p
),
udev_device_get_devpath=([udev_device_p], c_char_p),
udev_device_get_subsystem=([udev_device_p], c_char_p),
udev_device_get_syspath=([udev_device_p], c_char_p),
udev_device_get_sysnum=([udev_device_p], c_char_p),
udev_device_get_sysname=([udev_device_p], c_char_p),
udev_device_get_driver=([udev_device_p], c_char_p),
udev_device_get_devtype=([udev_device_p], c_char_p),
udev_device_get_devnode=([udev_device_p], c_char_p),
udev_device_get_property_value=([udev_device_p, c_char_p], c_char_p),
udev_device_get_sysattr_value=([udev_device_p, c_char_p], c_char_p),
udev_device_get_devnum=([udev_device_p], dev_t),
udev_device_get_action=([udev_device_p], c_char_p),
udev_device_get_seqnum=([udev_device_p], c_ulonglong),
udev_device_get_is_initialized=([udev_device_p], c_int),
udev_device_get_usec_since_initialized=([udev_device_p], c_ulonglong),
udev_device_get_devlinks_list_entry=([udev_device_p], udev_list_entry_p),
udev_device_get_tags_list_entry=([udev_device_p], udev_list_entry_p),
udev_device_get_properties_list_entry=([udev_device_p], udev_list_entry_p),
udev_device_get_sysattr_list_entry=([udev_device_p], udev_list_entry_p),
udev_device_set_sysattr_value=([udev_device_p, c_char_p, c_char_p], c_int),
udev_device_has_tag=([udev_device_p, c_char_p], c_int),
# monitoring
udev_monitor_ref=([udev_monitor_p], udev_monitor_p),
udev_monitor_unref=([udev_monitor_p], None),
udev_monitor_new_from_netlink=([udev_p, c_char_p], udev_monitor_p),
udev_monitor_enable_receiving=([udev_monitor_p], c_int),
udev_monitor_set_receive_buffer_size=([udev_monitor_p, c_int], c_int),
udev_monitor_get_fd=([udev_monitor_p], c_int),
udev_monitor_receive_device=([udev_monitor_p], udev_device_p),
udev_monitor_filter_add_match_subsystem_devtype=(
[udev_monitor_p, c_char_p, c_char_p], c_int),
udev_monitor_filter_add_match_tag=([udev_monitor_p, c_char_p], c_int),
udev_monitor_filter_update=([udev_monitor_p], c_int),
udev_monitor_filter_remove=([udev_monitor_p], c_int),
# hwdb
udev_hwdb_ref=([udev_hwdb_p], udev_hwdb_p),
udev_hwdb_unref=([udev_hwdb_p], None),
udev_hwdb_new=([udev_p], udev_hwdb_p),
udev_hwdb_get_properties_list_entry=(
[udev_hwdb_p, c_char_p, c_uint],
udev_list_entry_p
)
)
ERROR_CHECKERS = dict(
udev_device_get_action=None,
udev_device_get_devlinks_list_entry=None,
udev_device_get_devnode=None,
udev_device_get_devnum=None,
udev_device_get_devpath=None,
udev_device_get_devtype=None,
udev_device_get_driver=None,
udev_device_get_is_initialized=None,
udev_device_get_parent=None,
udev_device_get_parent_with_subsystem_devtype=None,
udev_device_get_properties_list_entry=None,
udev_device_get_property_value=None,
udev_device_get_seqnum=None,
udev_device_get_subsystem=None,
udev_device_get_sysattr_list_entry=None,
udev_device_get_sysattr_value=None,
udev_device_get_sysname=None,
udev_device_get_sysnum=None,
udev_device_get_syspath=None,
udev_device_get_tags_list_entry=None,
udev_device_get_usec_since_initialized=None,
udev_device_has_tag=None,
udev_device_new_from_device_id=None,
udev_device_new_from_devnum=None,
udev_device_new_from_environment=None,
udev_device_new_from_subsystem_sysname=None,
udev_device_new_from_syspath=None,
udev_device_ref=None,
udev_device_unref=None,
udev_device_set_sysattr_value=check_negative_errorcode,
udev_enumerate_add_match_parent=check_negative_errorcode,
udev_enumerate_add_match_subsystem=check_negative_errorcode,
udev_enumerate_add_nomatch_subsystem=check_negative_errorcode,
udev_enumerate_add_match_property=check_negative_errorcode,
udev_enumerate_add_match_sysattr=check_negative_errorcode,
udev_enumerate_add_nomatch_sysattr=check_negative_errorcode,
udev_enumerate_add_match_tag=check_negative_errorcode,
udev_enumerate_add_match_sysname=check_negative_errorcode,
udev_enumerate_add_match_is_initialized=check_negative_errorcode,
udev_enumerate_get_list_entry=None,
udev_enumerate_new=None,
udev_enumerate_ref=None,
udev_enumerate_scan_devices=None,
udev_enumerate_unref=None,
udev_get_dev_path=None,
udev_get_log_priority=None,
udev_get_run_path=None,
udev_get_sys_path=None,
udev_hwdb_get_properties_list_entry=None,
udev_hwdb_new=None,
udev_hwdb_ref=None,
udev_hwdb_unref=None,
udev_list_entry_get_name=None,
udev_list_entry_get_next=None,
udev_list_entry_get_value=None,
udev_monitor_set_receive_buffer_size=check_errno_on_nonzero_return,
# libudev doc says, enable_receiving returns a negative errno, but tests
# show that this is not reliable, so query the real error code
udev_monitor_enable_receiving=check_errno_on_nonzero_return,
udev_monitor_receive_device=check_errno_on_null_pointer_return,
udev_monitor_ref=None,
udev_monitor_filter_add_match_subsystem_devtype=check_negative_errorcode,
udev_monitor_filter_add_match_tag=check_negative_errorcode,
udev_monitor_filter_update=check_errno_on_nonzero_return,
udev_monitor_filter_remove=check_errno_on_nonzero_return,
udev_monitor_get_fd=None,
udev_monitor_new_from_netlink=None,
udev_monitor_unref=None,
udev_new=None,
udev_ref=None,
udev_set_log_priority=None,
udev_unref=None
)
_ctypeslib/utils.py 0000644 00000004651 15035142004 0010413 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2013 Sebastian Wiesner <lunaryorn@gmail.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev._ctypeslib.utils
=======================
Utilities for loading ctypeslib.
.. moduleauthor:: Anne Mulhern <amulhern@redhat.com>
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from ctypes import CDLL
from ctypes.util import find_library
def load_ctypes_library(name, signatures, error_checkers):
"""
Load library ``name`` and return a :class:`ctypes.CDLL` object for it.
:param str name: the library name
:param signatures: signatures of methods
:type signatures: dict of str * (tuple of (list of type) * type)
:param error_checkers: error checkers for methods
:type error_checkers: dict of str * ((int * ptr * arglist) -> int)
The library has errno handling enabled.
Important functions are given proper signatures and return types to support
type checking and argument conversion.
:returns: a loaded library
:rtype: ctypes.CDLL
:raises ImportError: if the library is not found
"""
library_name = find_library(name)
if not library_name:
raise ImportError('No library named %s' % name)
lib = CDLL(library_name, use_errno=True)
# Add function signatures
for funcname, signature in signatures.items():
function = getattr(lib, funcname, None)
if function:
argtypes, restype = signature
function.argtypes = argtypes
function.restype = restype
errorchecker = error_checkers.get(funcname)
if errorchecker:
function.errcheck = errorchecker
return lib
_ctypeslib/libc.py 0000644 00000002474 15035142004 0010165 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2013 Sebastian Wiesner <lunaryorn@gmail.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev._ctypeslib.libc
======================
Wrappers for libc.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from ctypes import c_int
from ._errorcheckers import check_errno_on_nonzero_return
fd_pair = c_int * 2
SIGNATURES = dict(
pipe2=([fd_pair, c_int], c_int),
)
ERROR_CHECKERS = dict(
pipe2=check_errno_on_nonzero_return,
)
_ctypeslib/_errorcheckers.py 0000644 00000006241 15035142004 0012250 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2013 Sebastian Wiesner <lunaryorn@gmail.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev._ctypeslib._errorcheckers
================================
Error checkers for ctypes wrappers.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import os
import errno
from ctypes import get_errno
ERRNO_EXCEPTIONS = {
errno.ENOMEM: MemoryError,
errno.EOVERFLOW: OverflowError,
errno.EINVAL: ValueError
}
def exception_from_errno(errnum):
"""Create an exception from ``errnum``.
``errnum`` is an integral error number.
Return an exception object appropriate to ``errnum``.
"""
exception = ERRNO_EXCEPTIONS.get(errnum)
errorstr = os.strerror(errnum)
if exception is not None:
return exception(errorstr)
else:
return EnvironmentError(errnum, errorstr)
def check_negative_errorcode(result, func, *args):
"""Error checker for funtions, which return negative error codes.
If ``result`` is smaller than ``0``, it is interpreted as negative error
code, and an appropriate exception is raised:
- ``-ENOMEM`` raises a :exc:`~exceptions.MemoryError`
- ``-EOVERFLOW`` raises a :exc:`~exceptions.OverflowError`
- all other error codes raise :exc:`~exceptions.EnvironmentError`
If result is greater or equal to ``0``, it is returned unchanged.
"""
if result < 0:
# udev returns the *negative* errno code at this point
errnum = -result
raise exception_from_errno(errnum)
else:
return result
def check_errno_on_nonzero_return(result, func, *args):
"""Error checker to check the system ``errno`` as returned by
:func:`ctypes.get_errno()`.
If ``result`` is not ``0``, an exception according to this errno is raised.
Otherwise nothing happens.
"""
if result != 0:
errnum = get_errno()
if errnum != 0:
raise exception_from_errno(errnum)
return result
def check_errno_on_null_pointer_return(result, func, *args):
"""Error checker to check the system ``errno`` as returned by
:func:`ctypes.get_errno()`.
If ``result`` is a null pointer, an exception according to this errno is
raised. Otherwise nothing happens.
"""
# pylint: disable=invalid-name
if not result:
errnum = get_errno()
if errnum != 0:
raise exception_from_errno(errnum)
return result
core.py 0000644 00000032163 15035142004 0006045 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2010, 2011 Sebastian Wiesner <lunaryorn@gmail.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev.core
===========
Core types and functions of :mod:`pyudev`.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
"""
from __future__ import (print_function, division, unicode_literals,
absolute_import)
from pyudev.device import Devices
from pyudev.device._errors import DeviceNotFoundAtPathError
from pyudev._ctypeslib.libudev import ERROR_CHECKERS
from pyudev._ctypeslib.libudev import SIGNATURES
from pyudev._ctypeslib.utils import load_ctypes_library
from pyudev._util import ensure_byte_string
from pyudev._util import ensure_unicode_string
from pyudev._util import property_value_to_bytes
from pyudev._util import udev_list_iterate
class Context(object):
"""
A device database connection.
This class represents a connection to the udev device database, and is
really *the* central object to access udev. You need an instance of this
class for almost anything else in pyudev.
This class itself gives access to various udev configuration data (e.g.
:attr:`sys_path`, :attr:`device_path`), and provides device enumeration
(:meth:`list_devices()`).
Instances of this class can directly be given as ``udev *`` to functions
wrapped through :mod:`ctypes`.
"""
def __init__(self):
"""
Create a new context.
"""
self._libudev = load_ctypes_library('udev', SIGNATURES, ERROR_CHECKERS)
self._as_parameter_ = self._libudev.udev_new()
def __del__(self):
self._libudev.udev_unref(self)
@property
def sys_path(self):
"""
The ``sysfs`` mount point defaulting to ``/sys'`` as unicode string.
"""
if hasattr(self._libudev, 'udev_get_sys_path'):
return ensure_unicode_string(self._libudev.udev_get_sys_path(self))
else:
# Fixed path since udev 183
return '/sys'
@property
def device_path(self):
"""
The device directory path defaulting to ``/dev`` as unicode string.
"""
if hasattr(self._libudev, 'udev_get_dev_path'):
return ensure_unicode_string(self._libudev.udev_get_dev_path(self))
else:
# Fixed path since udev 183
return '/dev'
@property
def run_path(self):
"""
The run runtime directory path defaulting to ``/run`` as unicode
string.
.. udevversion:: 167
.. versionadded:: 0.10
"""
if hasattr(self._libudev, 'udev_get_run_path'):
return ensure_unicode_string(self._libudev.udev_get_run_path(self))
else:
return '/run/udev'
@property
def log_priority(self):
"""
The logging priority of the interal logging facitility of udev as
integer with a standard :mod:`syslog` priority. Assign to this
property to change the logging priority.
UDev uses the standard :mod:`syslog` priorities. Constants for these
priorities are defined in the :mod:`syslog` module in the standard
library:
>>> import syslog
>>> context = pyudev.Context()
>>> context.log_priority = syslog.LOG_DEBUG
.. versionadded:: 0.9
"""
return self._libudev.udev_get_log_priority(self)
@log_priority.setter
def log_priority(self, value):
"""
Set the log priority.
:param int value: the log priority.
"""
self._libudev.udev_set_log_priority(self, value)
def list_devices(self, **kwargs):
"""
List all available devices.
The arguments of this method are the same as for
:meth:`Enumerator.match()`. In fact, the arguments are simply passed
straight to method :meth:`~Enumerator.match()`.
This function creates and returns an :class:`Enumerator` object,
that can be used to filter the list of devices, and eventually
retrieve :class:`Device` objects representing matching devices.
.. versionchanged:: 0.8
Accept keyword arguments now for easy matching.
"""
return Enumerator(self).match(**kwargs)
class Enumerator(object):
"""
A filtered iterable of devices.
To retrieve devices, simply iterate over an instance of this class.
This operation yields :class:`Device` objects representing the available
devices.
Before iteration the device list can be filtered by subsystem or by
property values using :meth:`match_subsystem` and
:meth:`match_property`. Multiple subsystem (property) filters are
combined using a logical OR, filters of different types are combined
using a logical AND. The following filter for instance::
devices.match_subsystem('block').match_property(
'ID_TYPE', 'disk').match_property('DEVTYPE', 'disk')
means the following::
subsystem == 'block' and (ID_TYPE == 'disk' or DEVTYPE == 'disk')
Once added, a filter cannot be removed anymore. Create a new object
instead.
Instances of this class can directly be given as given ``udev_enumerate *``
to functions wrapped through :mod:`ctypes`.
"""
def __init__(self, context):
"""
Create a new enumerator with the given ``context`` (a
:class:`Context` instance).
While you can create objects of this class directly, this is not
recommended. Call :method:`Context.list_devices()` instead.
"""
if not isinstance(context, Context):
raise TypeError('Invalid context object')
self.context = context
self._as_parameter_ = context._libudev.udev_enumerate_new(context)
self._libudev = context._libudev
def __del__(self):
self._libudev.udev_enumerate_unref(self)
def match(self, **kwargs):
"""
Include devices according to the rules defined by the keyword
arguments. These keyword arguments are interpreted as follows:
- The value for the keyword argument ``subsystem`` is forwarded to
:meth:`match_subsystem()`.
- The value for the keyword argument ``sys_name`` is forwared to
:meth:`match_sys_name()`.
- The value for the keyword argument ``tag`` is forwared to
:meth:`match_tag()`.
- The value for the keyword argument ``parent`` is forwared to
:meth:`match_parent()`.
- All other keyword arguments are forwareded one by one to
:meth:`match_property()`. The keyword argument itself is interpreted
as property name, the value of the keyword argument as the property
value.
All keyword arguments are optional, calling this method without no
arguments at all is simply a noop.
Return the instance again.
.. versionadded:: 0.8
.. versionchanged:: 0.13
Add ``parent`` keyword.
"""
subsystem = kwargs.pop('subsystem', None)
if subsystem is not None:
self.match_subsystem(subsystem)
sys_name = kwargs.pop('sys_name', None)
if sys_name is not None:
self.match_sys_name(sys_name)
tag = kwargs.pop('tag', None)
if tag is not None:
self.match_tag(tag)
parent = kwargs.pop('parent', None)
if parent is not None:
self.match_parent(parent)
for prop, value in kwargs.items():
self.match_property(prop, value)
return self
def match_subsystem(self, subsystem, nomatch=False):
"""
Include all devices, which are part of the given ``subsystem``.
``subsystem`` is either a unicode string or a byte string, containing
the name of the subsystem. If ``nomatch`` is ``True`` (default is
``False``), the match is inverted: A device is only included if it is
*not* part of the given ``subsystem``.
Note that, if a device has no subsystem, it is not included either
with value of ``nomatch`` True or with value of ``nomatch`` False.
Return the instance again.
"""
match = self._libudev.udev_enumerate_add_nomatch_subsystem \
if nomatch else self._libudev.udev_enumerate_add_match_subsystem
match(self, ensure_byte_string(subsystem))
return self
def match_sys_name(self, sys_name):
"""
Include all devices with the given name.
``sys_name`` is a byte or unicode string containing the device name.
Return the instance again.
.. versionadded:: 0.8
"""
self._libudev.udev_enumerate_add_match_sysname(
self, ensure_byte_string(sys_name))
return self
def match_property(self, prop, value):
"""
Include all devices, whose ``prop`` has the given ``value``.
``prop`` is either a unicode string or a byte string, containing
the name of the property to match. ``value`` is a property value,
being one of the following types:
- :func:`int`
- :func:`bool`
- A byte string
- Anything convertable to a unicode string (including a unicode string
itself)
Return the instance again.
"""
self._libudev.udev_enumerate_add_match_property(
self, ensure_byte_string(prop), property_value_to_bytes(value))
return self
def match_attribute(self, attribute, value, nomatch=False):
"""
Include all devices, whose ``attribute`` has the given ``value``.
``attribute`` is either a unicode string or a byte string, containing
the name of a sys attribute to match. ``value`` is an attribute value,
being one of the following types:
- :func:`int`,
- :func:`bool`
- A byte string
- Anything convertable to a unicode string (including a unicode string
itself)
If ``nomatch`` is ``True`` (default is ``False``), the match is
inverted: A device is include if the ``attribute`` does *not* match
the given ``value``.
.. note::
If ``nomatch`` is ``True``, devices which do not have the given
``attribute`` at all are also included. In other words, with
``nomatch=True`` the given ``attribute`` is *not* guaranteed to
exist on all returned devices.
Return the instance again.
"""
match = (self._libudev.udev_enumerate_add_match_sysattr
if not nomatch else
self._libudev.udev_enumerate_add_nomatch_sysattr)
match(self, ensure_byte_string(attribute),
property_value_to_bytes(value))
return self
def match_tag(self, tag):
"""
Include all devices, which have the given ``tag`` attached.
``tag`` is a byte or unicode string containing the tag name.
Return the instance again.
.. udevversion:: 154
.. versionadded:: 0.6
"""
self._libudev.udev_enumerate_add_match_tag(self, ensure_byte_string(tag))
return self
def match_is_initialized(self):
"""
Include only devices, which are initialized.
Initialized devices have properly set device node permissions and
context, and are (in case of network devices) fully renamed.
Currently this will not affect devices which do not have device nodes
and are not network interfaces.
Return the instance again.
.. seealso:: :attr:`Device.is_initialized`
.. udevversion:: 165
.. versionadded:: 0.8
"""
self._libudev.udev_enumerate_add_match_is_initialized(self)
return self
def match_parent(self, parent):
"""
Include all devices on the subtree of the given ``parent`` device.
The ``parent`` device itself is also included.
``parent`` is a :class:`~pyudev.Device`.
Return the instance again.
.. udevversion:: 172
.. versionadded:: 0.13
"""
self._libudev.udev_enumerate_add_match_parent(self, parent)
return self
def __iter__(self):
"""
Iterate over all matching devices.
Yield :class:`Device` objects.
"""
self._libudev.udev_enumerate_scan_devices(self)
entry = self._libudev.udev_enumerate_get_list_entry(self)
for name, _ in udev_list_iterate(self._libudev, entry):
try:
yield Devices.from_sys_path(self.context, name)
except DeviceNotFoundAtPathError:
continue
version.py 0000644 00000002115 15035142004 0006574 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2015 mulhern <amulhern@redhat.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev.version
==============
Version information.
.. moduleauthor:: mulhern <amulhern@redhat.com>
"""
__version_info__ = (0, 21, 0, '')
__version__ = "%s%s" % \
(
".".join(str(x) for x in __version_info__[:3]),
"".join(str(x) for x in __version_info__[3:])
)
_qt_base.py 0000644 00000015553 15035142004 0006676 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2010, 2011, 2012, 2013 Sebastian Wiesner <lunaryorn@gmail.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev._qt_base
===============
Base mixin class for Qt4,Qt5 support.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import six
from pyudev.device import Device
class MonitorObserverMixin(object):
"""
Base mixin for pyqt monitor observers.
"""
# pylint: disable=too-few-public-methods
def _setup_notifier(self, monitor, notifier_class):
self.monitor = monitor
self.notifier = notifier_class(
monitor.fileno(), notifier_class.Read, self)
self.notifier.activated[int].connect(self._process_udev_event)
@property
def enabled(self):
"""
Whether this observer is enabled or not.
If ``True`` (the default), this observer is enabled, and emits events.
Otherwise it is disabled and does not emit any events. This merely
reflects the state of the ``enabled`` property of the underlying
:attr:`notifier`.
.. versionadded:: 0.14
"""
return self.notifier.isEnabled()
@enabled.setter
def enabled(self, value):
self.notifier.setEnabled(value)
def _process_udev_event(self):
"""
Attempt to receive a single device event from the monitor, process
the event and emit corresponding signals.
Called by ``QSocketNotifier``, if data is available on the udev
monitoring socket.
"""
device = self.monitor.poll(timeout=0)
if device is not None:
self._emit_event(device)
def _emit_event(self, device):
self.deviceEvent.emit(device)
class QUDevMonitorObserverMixin(MonitorObserverMixin):
"""
Obsolete monitor observer mixin.
"""
# pylint: disable=too-few-public-methods
def _setup_notifier(self, monitor, notifier_class):
MonitorObserverMixin._setup_notifier(self, monitor, notifier_class)
self._action_signal_map = {
'add': self.deviceAdded, 'remove': self.deviceRemoved,
'change': self.deviceChanged, 'move': self.deviceMoved,
}
import warnings
warnings.warn('Will be removed in 1.0. '
'Use pyudev.pyqt4.MonitorObserver instead.',
DeprecationWarning)
def _emit_event(self, device):
self.deviceEvent.emit(device.action, device)
signal = self._action_signal_map.get(device.action)
if signal is not None:
signal.emit(device)
def make_init(qobject, socket_notifier):
"""
Generates an initializer to observer the given ``monitor``
(a :class:`~pyudev.Monitor`):
``parent`` is the parent :class:`~PyQt{4,5}.QtCore.QObject` of this
object. It is passed unchanged to the inherited constructor of
:class:`~PyQt{4,5}.QtCore.QObject`.
"""
def __init__(self, monitor, parent=None):
qobject.__init__(self, parent)
# pylint: disable=protected-access
self._setup_notifier(monitor, socket_notifier)
return __init__
class MonitorObserverGenerator(object):
"""
Class to generate a MonitorObserver class.
"""
# pylint: disable=too-few-public-methods
@staticmethod
def make_monitor_observer(qobject, signal, socket_notifier):
"""Generates an observer for device events integrating into the
PyQt{4,5} mainloop.
This class inherits :class:`~PyQt{4,5}.QtCore.QObject` to turn device
events into Qt signals:
>>> from pyudev import Context, Monitor
>>> from pyudev.pyqt4 import MonitorObserver
>>> context = Context()
>>> monitor = Monitor.from_netlink(context)
>>> monitor.filter_by(subsystem='input')
>>> observer = MonitorObserver(monitor)
>>> def device_event(device):
... print('event {0} on device {1}'.format(device.action, device))
>>> observer.deviceEvent.connect(device_event)
>>> monitor.start()
This class is a child of :class:`~{PySide, PyQt{4,5}}.QtCore.QObject`.
"""
return type(
str("MonitorObserver"),
(qobject, MonitorObserverMixin),
{
str("__init__") : make_init(qobject, socket_notifier),
str("deviceEvent") : signal(Device)
}
)
class QUDevMonitorObserverGenerator(object):
"""
Class to generate a MonitorObserver class.
"""
# pylint: disable=too-few-public-methods
@staticmethod
def make_monitor_observer(qobject, signal, socket_notifier):
"""Generates an observer for device events integrating into the
PyQt{4,5} mainloop.
This class inherits :class:`~PyQt{4,5}.QtCore.QObject` to turn device
events into Qt signals:
>>> from pyudev import Context, Monitor
>>> from pyudev.pyqt4 import MonitorObserver
>>> context = Context()
>>> monitor = Monitor.from_netlink(context)
>>> monitor.filter_by(subsystem='input')
>>> observer = MonitorObserver(monitor)
>>> def device_event(device):
... print('event {0} on device {1}'.format(device.action, device))
>>> observer.deviceEvent.connect(device_event)
>>> monitor.start()
This class is a child of :class:`~{PyQt{4,5}, PySide}.QtCore.QObject`.
"""
return type(
str("QUDevMonitorObserver"),
(qobject, QUDevMonitorObserverMixin),
{
str("__init__") : make_init(qobject, socket_notifier),
#: emitted upon arbitrary device events
str("deviceEvent") : signal(six.text_type, Device),
#: emitted if a device was added
str("deviceAdded") : signal(Device),
#: emitted if a device was removed
str("deviceRemoved") : signal(Device),
#: emitted if a device was changed
str("deviceChanged") : signal(Device),
#: emitted if a device was moved
str("deviceMoved") : signal(Device)
}
)
_os/__init__.py 0000644 00000001741 15035142004 0007432 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2015 mulhern <amulhern@redhat.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev._os
==========
Extras to compensate for deficiencies in python os module.
.. moduleauthor:: mulhern <amulhern@redhat.com>
"""
from . import pipe
from . import poll
_os/pipe.py 0000644 00000010703 15035142004 0006626 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2013 Sebastian Wiesner <lunaryorn@gmail.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev._os.pipe
===============
Fallback implementations for pipe.
1. pipe2 from python os module
2. pipe2 from libc
3. pipe from python os module
The Pipe class wraps the chosen implementation.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import os
import fcntl
from functools import partial
from pyudev._ctypeslib.libc import fd_pair
from pyudev._ctypeslib.libc import ERROR_CHECKERS
from pyudev._ctypeslib.libc import SIGNATURES
from pyudev._ctypeslib.utils import load_ctypes_library
# Define O_CLOEXEC, if not present in os already
O_CLOEXEC = getattr(os, 'O_CLOEXEC', 0o2000000)
def _pipe2_ctypes(libc, flags):
"""A ``pipe2`` implementation using ``pipe2`` from ctypes.
``libc`` is a :class:`ctypes.CDLL` object for libc. ``flags`` is an
integer providing the flags to ``pipe2``.
Return a pair of file descriptors ``(r, w)``.
"""
fds = fd_pair()
libc.pipe2(fds, flags)
return fds[0], fds[1]
def _pipe2_by_pipe(flags):
"""A ``pipe2`` implementation using :func:`os.pipe`.
``flags`` is an integer providing the flags to ``pipe2``.
.. warning::
This implementation is not atomic!
Return a pair of file descriptors ``(r, w)``.
"""
fds = os.pipe()
if flags & os.O_NONBLOCK != 0:
for fd in fds:
set_fd_status_flag(fd, os.O_NONBLOCK)
if flags & O_CLOEXEC != 0:
for fd in fds:
set_fd_flag(fd, O_CLOEXEC)
return fds
def _get_pipe2_implementation():
"""Find the appropriate implementation for ``pipe2``.
Return a function implementing ``pipe2``."""
if hasattr(os, 'pipe2'):
return os.pipe2 # pylint: disable=no-member
else:
try:
libc = load_ctypes_library("libc", SIGNATURES, ERROR_CHECKERS)
return (partial(_pipe2_ctypes, libc)
if hasattr(libc, 'pipe2') else
_pipe2_by_pipe)
except ImportError:
return _pipe2_by_pipe
_PIPE2 = _get_pipe2_implementation()
def set_fd_flag(fd, flag):
"""Set a flag on a file descriptor.
``fd`` is the file descriptor or file object, ``flag`` the flag as integer.
"""
flags = fcntl.fcntl(fd, fcntl.F_GETFD, 0)
fcntl.fcntl(fd, fcntl.F_SETFD, flags | flag)
def set_fd_status_flag(fd, flag):
"""Set a status flag on a file descriptor.
``fd`` is the file descriptor or file object, ``flag`` the flag as integer.
"""
flags = fcntl.fcntl(fd, fcntl.F_GETFL, 0)
fcntl.fcntl(fd, fcntl.F_SETFL, flags | flag)
class Pipe(object):
"""A unix pipe.
A pipe object provides two file objects: :attr:`source` is a readable file
object, and :attr:`sink` a writeable. Bytes written to :attr:`sink` appear
at :attr:`source`.
Open a pipe with :meth:`open()`.
"""
@classmethod
def open(cls):
"""Open and return a new :class:`Pipe`.
The pipe uses non-blocking IO."""
source, sink = _PIPE2(os.O_NONBLOCK | O_CLOEXEC)
return cls(source, sink)
def __init__(self, source_fd, sink_fd):
"""Create a new pipe object from the given file descriptors.
``source_fd`` is a file descriptor for the readable side of the pipe,
``sink_fd`` is a file descriptor for the writeable side."""
self.source = os.fdopen(source_fd, 'rb', 0)
self.sink = os.fdopen(sink_fd, 'wb', 0)
def close(self):
"""Closes both sides of the pipe."""
try:
self.source.close()
finally:
self.sink.close()
_os/__pycache__/pipe.cpython-36.pyc 0000644 00000007657 15035142004 0013130 0 ustar 00 3
u1�W� � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlZddlm Z ddl
m Z dd l
m Z dd
l
m
Z
dd lmZ eed d
�Zdd� Zdd� Zdd� Ze� Zdd� Zdd� ZG dd� de�ZdS )a#
pyudev._os.pipe
===============
Fallback implementations for pipe.
1. pipe2 from python os module
2. pipe2 from libc
3. pipe from python os module
The Pipe class wraps the chosen implementation.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literalsN)�partial)�fd_pair)�ERROR_CHECKERS)�
SIGNATURES)�load_ctypes_library� O_CLOEXECi c C s" t � }| j||� |d |d fS )z�A ``pipe2`` implementation using ``pipe2`` from ctypes.
``libc`` is a :class:`ctypes.CDLL` object for libc. ``flags`` is an
integer providing the flags to ``pipe2``.
Return a pair of file descriptors ``(r, w)``.
r � )r �pipe2)�libc�flags�fds� r �/usr/lib/python3.6/pipe.py�
_pipe2_ctypes4 s r c C sX t j� }| t j@ dkr0x|D ]}t|t j� q W | t@ dkrTx|D ]}t|t� qBW |S )z�A ``pipe2`` implementation using :func:`os.pipe`.
``flags`` is an integer providing the flags to ``pipe2``.
.. warning::
This implementation is not atomic!
Return a pair of file descriptors ``(r, w)``.
r )�os�pipe�
O_NONBLOCK�set_fd_status_flagr � set_fd_flag)r r �fdr r r �_pipe2_by_pipeB s
r c C sN t td�rtjS y$tdtt�} t | d�r2tt| �S tS t k
rH tS X dS )z]Find the appropriate implementation for ``pipe2``.
Return a function implementing ``pipe2``.r
r N)
�hasattrr r
r
r r r r r � ImportError)r r r r �_get_pipe2_implementationX s
r c C s( t j | t jd�}t j | t j||B � dS )zwSet a flag on a file descriptor.
``fd`` is the file descriptor or file object, ``flag`` the flag as integer.
r N)�fcntlZF_GETFDZF_SETFD)r �flagr r r r r k s r c C s( t j | t jd�}t j | t j||B � dS )z~Set a status flag on a file descriptor.
``fd`` is the file descriptor or file object, ``flag`` the flag as integer.
r N)r ZF_GETFLZF_SETFL)r r r r r r r u s r c @ s, e Zd ZdZedd� �Zdd� Zdd� ZdS ) �Pipez�A unix pipe.
A pipe object provides two file objects: :attr:`source` is a readable file
object, and :attr:`sink` a writeable. Bytes written to :attr:`sink` appear
at :attr:`source`.
Open a pipe with :meth:`open()`.
c C s t tjtB �\}}| ||�S )zLOpen and return a new :class:`Pipe`.
The pipe uses non-blocking IO.)�_PIPE2r r r )�cls�source�sinkr r r �open� s z Pipe.openc C s$ t j|dd�| _t j|dd�| _dS )z�Create a new pipe object from the given file descriptors.
``source_fd`` is a file descriptor for the readable side of the pipe,
``sink_fd`` is a file descriptor for the writeable side.�rbr �wbN)r �fdopenr# r$ )�selfZ source_fdZsink_fdr r r �__init__� s z
Pipe.__init__c
C s z| j j� W d| jj� X dS )z Closes both sides of the pipe.N)r# �closer$ )r) r r r r+ � s z
Pipe.closeN)�__name__�
__module__� __qualname__�__doc__� classmethodr% r* r+ r r r r r s r )r/ Z
__future__r r r r r r � functoolsr Zpyudev._ctypeslib.libcr r r Zpyudev._ctypeslib.utilsr
�getattrr r r r r! r r �objectr r r r r �<module> s&
_os/__pycache__/pipe.cpython-36.opt-1.pyc 0000644 00000007657 15035142004 0014067 0 ustar 00 3
u1�W� � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlZddlm Z ddl
m Z dd l
m Z dd
l
m
Z
dd lmZ eed d
�Zdd� Zdd� Zdd� Ze� Zdd� Zdd� ZG dd� de�ZdS )a#
pyudev._os.pipe
===============
Fallback implementations for pipe.
1. pipe2 from python os module
2. pipe2 from libc
3. pipe from python os module
The Pipe class wraps the chosen implementation.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literalsN)�partial)�fd_pair)�ERROR_CHECKERS)�
SIGNATURES)�load_ctypes_library� O_CLOEXECi c C s" t � }| j||� |d |d fS )z�A ``pipe2`` implementation using ``pipe2`` from ctypes.
``libc`` is a :class:`ctypes.CDLL` object for libc. ``flags`` is an
integer providing the flags to ``pipe2``.
Return a pair of file descriptors ``(r, w)``.
r � )r �pipe2)�libc�flags�fds� r �/usr/lib/python3.6/pipe.py�
_pipe2_ctypes4 s r c C sX t j� }| t j@ dkr0x|D ]}t|t j� q W | t@ dkrTx|D ]}t|t� qBW |S )z�A ``pipe2`` implementation using :func:`os.pipe`.
``flags`` is an integer providing the flags to ``pipe2``.
.. warning::
This implementation is not atomic!
Return a pair of file descriptors ``(r, w)``.
r )�os�pipe�
O_NONBLOCK�set_fd_status_flagr � set_fd_flag)r r �fdr r r �_pipe2_by_pipeB s
r c C sN t td�rtjS y$tdtt�} t | d�r2tt| �S tS t k
rH tS X dS )z]Find the appropriate implementation for ``pipe2``.
Return a function implementing ``pipe2``.r
r N)
�hasattrr r
r
r r r r r � ImportError)r r r r �_get_pipe2_implementationX s
r c C s( t j | t jd�}t j | t j||B � dS )zwSet a flag on a file descriptor.
``fd`` is the file descriptor or file object, ``flag`` the flag as integer.
r N)�fcntlZF_GETFDZF_SETFD)r �flagr r r r r k s r c C s( t j | t jd�}t j | t j||B � dS )z~Set a status flag on a file descriptor.
``fd`` is the file descriptor or file object, ``flag`` the flag as integer.
r N)r ZF_GETFLZF_SETFL)r r r r r r r u s r c @ s, e Zd ZdZedd� �Zdd� Zdd� ZdS ) �Pipez�A unix pipe.
A pipe object provides two file objects: :attr:`source` is a readable file
object, and :attr:`sink` a writeable. Bytes written to :attr:`sink` appear
at :attr:`source`.
Open a pipe with :meth:`open()`.
c C s t tjtB �\}}| ||�S )zLOpen and return a new :class:`Pipe`.
The pipe uses non-blocking IO.)�_PIPE2r r r )�cls�source�sinkr r r �open� s z Pipe.openc C s$ t j|dd�| _t j|dd�| _dS )z�Create a new pipe object from the given file descriptors.
``source_fd`` is a file descriptor for the readable side of the pipe,
``sink_fd`` is a file descriptor for the writeable side.�rbr �wbN)r �fdopenr# r$ )�selfZ source_fdZsink_fdr r r �__init__� s z
Pipe.__init__c
C s z| j j� W d| jj� X dS )z Closes both sides of the pipe.N)r# �closer$ )r) r r r r+ � s z
Pipe.closeN)�__name__�
__module__� __qualname__�__doc__� classmethodr% r* r+ r r r r r s r )r/ Z
__future__r r r r r r � functoolsr Zpyudev._ctypeslib.libcr r r Zpyudev._ctypeslib.utilsr
�getattrr r r r r! r r �objectr r r r r �<module> s&
_os/__pycache__/poll.cpython-36.pyc 0000644 00000006434 15035142004 0013131 0 ustar 00 3
�W � @ s\ d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlmZ G dd � d e �Z
dS )
z�
pyudev._os.poll
===============
Operating system interface for pyudev.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literalsN)�eintr_retry_callc @ sP e Zd ZdZejejd�Zedd� �Z e
dd� �Z dd� Z dd
d �Z
d d
� Zd S )�PollzwA poll object.
This object essentially provides a more convenient interface around
:class:`select.poll`.
)�r�wc C s | |@ dkS )Nr � )�events�eventr
r
�/usr/lib/python3.6/poll.py�
_has_event1 s zPoll._has_eventc G sN t tj�}x:|D ]2\}}| jj|�}|s6tdj|���|j||� qW | |�S )aG Listen for ``events``.
``events`` is a list of ``(fd, event)`` pairs, where ``fd`` is a file
descriptor or file object and ``event`` either ``'r'`` or ``'w'``. If
``r``, listen for whether that is ready to be read. If ``w``, listen
for whether the channel is ready to be written to.
zUnknown event type: {0!r})r �select�poll�_EVENT_TO_MASK�get�
ValueError�format�register)�clsr �notifier�fdr �maskr
r
r
�
for_events5 s
zPoll.for_eventsc C s
|| _ dS )z�Create a poll object for the given ``notifier``.
``notifier`` is the :class:`select.poll` object wrapped by the new poll
object.
N)� _notifier)�selfr r
r
r
�__init__G s z
Poll.__init__Nc C s t | jt| jj|���S )a{ Poll for events.
``timeout`` is an integer specifying how long to wait for events (in
milliseconds). If omitted, ``None`` or negative, wait until an event
occurs.
Return a list of all events that occurred before ``timeout``, where
each event is a pair ``(fd, event)``. ``fd`` is the integral file
descriptor, and ``event`` a string indicating the event type. If
``'r'``, there is data to read from ``fd``. If ``'w'``, ``fd`` is
writable without blocking now. If ``'h'``, the file descriptor was
hung up (i.e. the remote side of a pipe was closed).
)�list�
_parse_eventsr r r )r Ztimeoutr
r
r
r P s z Poll.pollc c s� x�|D ]�\}}| j |tj�r,tdj|���n | j |tj�rHtdj|���| j |tj�r`|dfV | j |tj�rx|dfV | j |tj�r|dfV qW dS )z�Parse ``events``.
``events`` is a list of events as returned by
:meth:`select.poll.poll()`.
Yield all parsed events.
z File descriptor not open: {0!r}z Error while polling fd: {0!r}r r �hN) r r ZPOLLNVAL�IOErrorr ZPOLLERR�POLLIN�POLLOUTZPOLLHUP)r r r Z
event_maskr
r
r
r c s
zPoll._parse_events)N)�__name__�
__module__� __qualname__�__doc__r r" r# r � staticmethodr � classmethodr r r r r
r
r
r
r & s
r ) r' Z
__future__r r r r r Z pyudev._utilr �objectr r
r
r
r
�<module> s _os/__pycache__/poll.cpython-36.opt-1.pyc 0000644 00000006434 15035142004 0014070 0 ustar 00 3
�W � @ s\ d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlmZ G dd � d e �Z
dS )
z�
pyudev._os.poll
===============
Operating system interface for pyudev.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literalsN)�eintr_retry_callc @ sP e Zd ZdZejejd�Zedd� �Z e
dd� �Z dd� Z dd
d �Z
d d
� Zd S )�PollzwA poll object.
This object essentially provides a more convenient interface around
:class:`select.poll`.
)�r�wc C s | |@ dkS )Nr � )�events�eventr
r
�/usr/lib/python3.6/poll.py�
_has_event1 s zPoll._has_eventc G sN t tj�}x:|D ]2\}}| jj|�}|s6tdj|���|j||� qW | |�S )aG Listen for ``events``.
``events`` is a list of ``(fd, event)`` pairs, where ``fd`` is a file
descriptor or file object and ``event`` either ``'r'`` or ``'w'``. If
``r``, listen for whether that is ready to be read. If ``w``, listen
for whether the channel is ready to be written to.
zUnknown event type: {0!r})r �select�poll�_EVENT_TO_MASK�get�
ValueError�format�register)�clsr �notifier�fdr �maskr
r
r
�
for_events5 s
zPoll.for_eventsc C s
|| _ dS )z�Create a poll object for the given ``notifier``.
``notifier`` is the :class:`select.poll` object wrapped by the new poll
object.
N)� _notifier)�selfr r
r
r
�__init__G s z
Poll.__init__Nc C s t | jt| jj|���S )a{ Poll for events.
``timeout`` is an integer specifying how long to wait for events (in
milliseconds). If omitted, ``None`` or negative, wait until an event
occurs.
Return a list of all events that occurred before ``timeout``, where
each event is a pair ``(fd, event)``. ``fd`` is the integral file
descriptor, and ``event`` a string indicating the event type. If
``'r'``, there is data to read from ``fd``. If ``'w'``, ``fd`` is
writable without blocking now. If ``'h'``, the file descriptor was
hung up (i.e. the remote side of a pipe was closed).
)�list�
_parse_eventsr r r )r Ztimeoutr
r
r
r P s z Poll.pollc c s� x�|D ]�\}}| j |tj�r,tdj|���n | j |tj�rHtdj|���| j |tj�r`|dfV | j |tj�rx|dfV | j |tj�r|dfV qW dS )z�Parse ``events``.
``events`` is a list of events as returned by
:meth:`select.poll.poll()`.
Yield all parsed events.
z File descriptor not open: {0!r}z Error while polling fd: {0!r}r r �hN) r r ZPOLLNVAL�IOErrorr ZPOLLERR�POLLIN�POLLOUTZPOLLHUP)r r r Z
event_maskr
r
r
r c s
zPoll._parse_events)N)�__name__�
__module__� __qualname__�__doc__r r" r# r � staticmethodr � classmethodr r r r r
r
r
r
r & s
r ) r' Z
__future__r r r r r Z pyudev._utilr �objectr r
r
r
r
�<module> s _os/__pycache__/__init__.cpython-36.pyc 0000644 00000000520 15035142004 0013710 0 ustar 00 3
H�V� � @ s d Z ddlmZ ddlmZ dS )z�
pyudev._os
==========
Extras to compensate for deficiencies in python os module.
.. moduleauthor:: mulhern <amulhern@redhat.com>
� )�pipe)�pollN)�__doc__� r r � r r � /usr/lib/python3.6/__init__.py�<module> s _os/__pycache__/__init__.cpython-36.opt-1.pyc 0000644 00000000520 15035142004 0014647 0 ustar 00 3
H�V� � @ s d Z ddlmZ ddlmZ dS )z�
pyudev._os
==========
Extras to compensate for deficiencies in python os module.
.. moduleauthor:: mulhern <amulhern@redhat.com>
� )�pipe)�pollN)�__doc__� r r � r r � /usr/lib/python3.6/__init__.py�<module> s _os/poll.py 0000644 00000010033 15035142004 0006633 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2013 Sebastian Wiesner <lunaryorn@gmail.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev._os.poll
===============
Operating system interface for pyudev.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import select
from pyudev._util import eintr_retry_call
class Poll(object):
"""A poll object.
This object essentially provides a more convenient interface around
:class:`select.poll`.
"""
_EVENT_TO_MASK = {'r': select.POLLIN,
'w': select.POLLOUT}
@staticmethod
def _has_event(events, event):
return events & event != 0
@classmethod
def for_events(cls, *events):
"""Listen for ``events``.
``events`` is a list of ``(fd, event)`` pairs, where ``fd`` is a file
descriptor or file object and ``event`` either ``'r'`` or ``'w'``. If
``r``, listen for whether that is ready to be read. If ``w``, listen
for whether the channel is ready to be written to.
"""
notifier = eintr_retry_call(select.poll)
for fd, event in events:
mask = cls._EVENT_TO_MASK.get(event)
if not mask:
raise ValueError('Unknown event type: {0!r}'.format(event))
notifier.register(fd, mask)
return cls(notifier)
def __init__(self, notifier):
"""Create a poll object for the given ``notifier``.
``notifier`` is the :class:`select.poll` object wrapped by the new poll
object.
"""
self._notifier = notifier
def poll(self, timeout=None):
"""Poll for events.
``timeout`` is an integer specifying how long to wait for events (in
milliseconds). If omitted, ``None`` or negative, wait until an event
occurs.
Return a list of all events that occurred before ``timeout``, where
each event is a pair ``(fd, event)``. ``fd`` is the integral file
descriptor, and ``event`` a string indicating the event type. If
``'r'``, there is data to read from ``fd``. If ``'w'``, ``fd`` is
writable without blocking now. If ``'h'``, the file descriptor was
hung up (i.e. the remote side of a pipe was closed).
"""
# Return a list to allow clients to determine whether there are any
# events at all with a simple truthiness test.
return list(self._parse_events(eintr_retry_call(self._notifier.poll, timeout)))
def _parse_events(self, events):
"""Parse ``events``.
``events`` is a list of events as returned by
:meth:`select.poll.poll()`.
Yield all parsed events.
"""
for fd, event_mask in events:
if self._has_event(event_mask, select.POLLNVAL):
raise IOError('File descriptor not open: {0!r}'.format(fd))
elif self._has_event(event_mask, select.POLLERR):
raise IOError('Error while polling fd: {0!r}'.format(fd))
if self._has_event(event_mask, select.POLLIN):
yield fd, 'r'
if self._has_event(event_mask, select.POLLOUT):
yield fd, 'w'
if self._has_event(event_mask, select.POLLHUP):
yield fd, 'h'
device/__init__.py 0000644 00000002517 15035142004 0010113 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2015 mulhern <amulhern@redhat.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev.device
=============
Device class implementation of :mod:`pyudev`.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
"""
from ._device import Attributes
from ._device import Device
from ._device import Devices
from ._device import Tags
from ._errors import DeviceNotFoundAtPathError
from ._errors import DeviceNotFoundByFileError
from ._errors import DeviceNotFoundByNameError
from ._errors import DeviceNotFoundByNumberError
from ._errors import DeviceNotFoundError
from ._errors import DeviceNotFoundInEnvironmentError
device/_errors.py 0000644 00000012154 15035142004 0010025 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2015 mulhern <amulhern@redhat.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev.device._errors
=====================
Errors raised by Device methods.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import abc
from six import add_metaclass
@add_metaclass(abc.ABCMeta)
class DeviceError(Exception):
"""
Any error raised when messing around w/ or trying to discover devices.
"""
@add_metaclass(abc.ABCMeta)
class DeviceNotFoundError(DeviceError):
"""
An exception indicating that no :class:`Device` was found.
.. versionchanged:: 0.5
Rename from ``NoSuchDeviceError`` to its current name.
"""
class DeviceNotFoundAtPathError(DeviceNotFoundError):
"""
A :exc:`DeviceNotFoundError` indicating that no :class:`Device` was
found at a given path.
"""
def __init__(self, sys_path):
DeviceNotFoundError.__init__(self, sys_path)
@property
def sys_path(self):
"""
The path that caused this error as string.
"""
return self.args[0]
def __str__(self):
return 'No device at {0!r}'.format(self.sys_path)
class DeviceNotFoundByFileError(DeviceNotFoundError):
"""
A :exc:`DeviceNotFoundError` indicating that no :class:`Device` was
found from the given filename.
"""
class DeviceNotFoundByInterfaceIndexError(DeviceNotFoundError):
"""
A :exc:`DeviceNotFoundError` indicating that no :class:`Device` was found
from the given interface index.
"""
class DeviceNotFoundByKernelDeviceError(DeviceNotFoundError):
"""
A :exc:`DeviceNotFoundError` indicating that no :class:`Device` was found
from the given kernel device string.
The format of the kernel device string is defined in the
systemd.journal-fields man pagees.
"""
class DeviceNotFoundByNameError(DeviceNotFoundError):
"""
A :exc:`DeviceNotFoundError` indicating that no :class:`Device` was
found with a given name.
"""
def __init__(self, subsystem, sys_name):
DeviceNotFoundError.__init__(self, subsystem, sys_name)
@property
def subsystem(self):
"""
The subsystem that caused this error as string.
"""
return self.args[0]
@property
def sys_name(self):
"""
The sys name that caused this error as string.
"""
return self.args[1]
def __str__(self):
return 'No device {0.sys_name!r} in {0.subsystem!r}'.format(self)
class DeviceNotFoundByNumberError(DeviceNotFoundError):
"""
A :exc:`DeviceNotFoundError` indicating, that no :class:`Device` was found
for a given device number.
"""
def __init__(self, typ, number):
DeviceNotFoundError.__init__(self, typ, number)
@property
def device_type(self):
"""
The device type causing this error as string. Either ``'char'`` or
``'block'``.
"""
return self.args[0]
@property
def device_number(self):
"""
The device number causing this error as integer.
"""
return self.args[1]
def __str__(self):
return ('No {0.device_type} device with number '
'{0.device_number}'.format(self))
class DeviceNotFoundInEnvironmentError(DeviceNotFoundError):
"""
A :exc:`DeviceNotFoundError` indicating, that no :class:`Device` could
be constructed from the process environment.
"""
def __str__(self):
return 'No device found in environment'
class DeviceValueError(DeviceError):
"""
Raised when a parameter has an unacceptable value.
May also be raised when the parameter has an unacceptable type.
"""
_FMT_STR = "value '%s' for parameter %s is unacceptable"
def __init__(self, value, param, msg=None):
""" Initializer.
:param object value: the value
:param str param: the parameter
:param str msg: an explanatory message
"""
# pylint: disable=super-init-not-called
self._value = value
self._param = param
self._msg = msg
def __str__(self):
if self._msg:
fmt_str = self._FMT_STR + ": %s"
return fmt_str % (self._value, self._param, self._msg)
else:
return self._FMT_STR % (self._value, self._param)
device/__pycache__/_device.cpython-36.opt-1.pyc 0000644 00000124641 15035142004 0015200 0 ustar 00 3
u1�Wɭ � @ sZ d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlZddlm Z ddlm
Z
dd lm Z dd
l m
Z
dd lmZ dd lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ G dd� de �Z G dd� de �Z G dd � d e �Z G d d � d e �Z G d d � d e
e �Z!dS )!z�
pyudev.device._device
=====================
Device class implementation of :mod:`pyudev`.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literalsN)� Container)�Iterable)�Mapping)� timedelta)�DeviceNotFoundAtPathError)�DeviceNotFoundByFileError)�#DeviceNotFoundByInterfaceIndexError)�!DeviceNotFoundByKernelDeviceError)�DeviceNotFoundByNameError)�DeviceNotFoundByNumberError)� DeviceNotFoundInEnvironmentError)�ensure_byte_string)�ensure_unicode_string)�get_device_type)�string_to_bool)�udev_list_iteratec @ s| e Zd ZdZedd� �Zedd� �Zedd� �Zedd � �Zed
d � �Z ed d
� �Z
edd� �Z edd� �Z edd� �Z
dS )�DeviceszT
Class for constructing :class:`Device` objects from various kinds of data.
c C s0 |j |j�s$tjj|j|jtj��}| j||�S )a�
Create a device from a device ``path``. The ``path`` may or may not
start with the ``sysfs`` mount point:
>>> from pyudev import Context, Device
>>> context = Context()
>>> Devices.from_path(context, '/devices/platform')
Device(u'/sys/devices/platform')
>>> Devices.from_path(context, '/sys/devices/platform')
Device(u'/sys/devices/platform')
``context`` is the :class:`Context` in which to search the device.
``path`` is a device path as unicode or byte string.
Return a :class:`Device` object for the device. Raise
:exc:`DeviceNotFoundAtPathError`, if no device was found for ``path``.
.. versionadded:: 0.18
)�
startswith�sys_path�os�path�join�lstrip�sep�
from_sys_path)�cls�contextr � r! � /usr/lib/python3.6/_device.py� from_path< s zDevices.from_pathc C s( |j j|t|��}|s t|��t||�S )a�
Create a new device from a given ``sys_path``:
>>> from pyudev import Context, Device
>>> context = Context()
>>> Devices.from_sys_path(context, '/sys/devices/platform')
Device(u'/sys/devices/platform')
``context`` is the :class:`Context` in which to search the device.
``sys_path`` is a unicode or byte string containing the path of the
device inside ``sysfs`` with the mount point included.
Return a :class:`Device` object for the device. Raise
:exc:`DeviceNotFoundAtPathError`, if no device was found for
``sys_path``.
.. versionadded:: 0.18
)�_libudevZ udev_device_new_from_syspathr r
�Device)r r r �devicer! r! r" r U s
zDevices.from_sys_pathc C s< |j dd�}|jj|t|�t|��}|s2t||��t||�S )a.
Create a new device from a given ``subsystem`` and a given
``sys_name``:
>>> from pyudev import Context, Device
>>> context = Context()
>>> sda = Devices.from_name(context, 'block', 'sda')
>>> sda
Device(u'/sys/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0/block/sda')
>>> sda == Devices.from_path(context, '/block/sda')
``context`` is the :class:`Context` in which to search the device.
``subsystem`` and ``sys_name`` are byte or unicode strings, which
denote the subsystem and the name of the device to create.
Return a :class:`Device` object for the device. Raise
:exc:`DeviceNotFoundByNameError`, if no device was found with the given
name.
.. versionadded:: 0.18
�/�!)�replacer$ Z&udev_device_new_from_subsystem_sysnamer r r% )r r � subsystem�sys_namer& r! r! r" � from_nameo s
zDevices.from_namec C s0 |j j|t|d �|�}|s&t||��t||�S )a�
Create a new device from a device ``number`` with the given device
``type``:
>>> import os
>>> from pyudev import Context, Device
>>> ctx = Context()
>>> major, minor = 8, 0
>>> device = Devices.from_device_number(context, 'block',
... os.makedev(major, minor))
>>> device
Device(u'/sys/devices/pci0000:00/0000:00:11.0/host0/target0:0:0/0:0:0:0/block/sda')
>>> os.major(device.device_number), os.minor(device.device_number)
(8, 0)
Use :func:`os.makedev` to construct a device number from a major and a
minor device number, as shown in the example above.
.. warning::
Device numbers are not unique across different device types.
Passing a correct number with a wrong type may silently yield a
wrong device object, so make sure to pass the correct device type.
``context`` is the :class:`Context`, in which to search the device.
``type`` is either ``'char'`` or ``'block'``, according to whether the
device is a character or block device. ``number`` is the device number
as integer.
Return a :class:`Device` object for the device with the given device
``number``. Raise :exc:`DeviceNotFoundByNumberError`, if no device was
found with the given device type and number.
.. versionadded:: 0.18
r )r$ Zudev_device_new_from_devnumr r r% )r r �typ�numberr& r! r! r" �from_device_number� s
%
zDevices.from_device_numberc C sV yt |�}tj|�j}W n. ttfk
rF } zt|��W Y dd}~X nX | j|||�S )a�
Create a new device from the given device file:
>>> from pyudev import Context, Device
>>> context = Context()
>>> device = Devices.from_device_file(context, '/dev/sda')
>>> device
Device(u'/sys/devices/pci0000:00/0000:00:0d.0/host2/target2:0:0/2:0:0:0/block/sda')
>>> device.device_node
u'/dev/sda'
.. warning::
Though the example seems to suggest that ``device.device_node ==
filename`` holds with ``device = Devices.from_device_file(context,
filename)``, this is only true in a majority of cases. There *can*
be devices, for which this relation is actually false! Thus, do
*not* expect :attr:`~Device.device_node` to be equal to the given
``filename`` for the returned :class:`Device`. Especially, use
:attr:`~Device.device_node` if you need the device file of a
:class:`Device` created with this method afterwards.
``context`` is the :class:`Context` in which to search the device.
``filename`` is a string containing the path of a device file.
Return a :class:`Device` representing the given device file. Raise
:exc:`DeviceNotFoundByFileError` if ``filename`` is no device file
at all or if ``filename`` does not exist or if its metadata was
inaccessible.
.. versionadded:: 0.18
N)r r �stat�st_rdev�EnvironmentError�
ValueErrorr r/ )r r �filename� device_type�
device_number�errr! r! r" �from_device_file� s "zDevices.from_device_filec s< |j dd�}t� fdd�|D �d�}|dk r0|S t� ��dS )a?
Locate a device based on the interface index.
:param `Context` context: the libudev context
:param int ifindex: the interface index
:returns: the device corresponding to the interface index
:rtype: `Device`
This method is only appropriate for network devices.
Znet)r* c 3 s" | ]}|j jd �� kr|V qdS )�ifindexN)�
attributes�get)�.0�d)r9 r! r" � <genexpr>� s z/Devices.from_interface_index.<locals>.<genexpr>N)� list_devices�nextr )r r r9 Znetwork_devicesZdevr! )r9 r" �from_interface_index� s z Devices.from_interface_indexc C s� |d }|dd� }|d krlt jd�}|j|�}|rbtjt|jd��t|jd���}| j|||�S t|��nT|d kr�| j ||�S |d
kr�|j
d �\}} }
|
r�|r�| j |||
�S t|��nt|��dS )
a
Locate a device based on the kernel device.
:param `Context` context: the libudev context
:param str kernel_device: the kernel device
:returns: the device corresponding to ``kernel_device``
:rtype: `Device`
r � N�b�cz ^(?P<major>\d+):(?P<minor>\d+)$�major�minor�n�+�:)rC rD ) �re�compile�matchr �makedev�int�groupr/ r
rA � partitionr, ) r r Z
kernel_deviceZ switch_char�restZ number_rerL r. r* �_Zkernel_device_namer! r! r" �from_kernel_device� s&
zDevices.from_kernel_devicec C s |j j|�}|st� �t||�S )a�
Create a new device from the process environment (as in
:data:`os.environ`).
This only works reliable, if the current process is called from an
udev rule, and is usually used for tools executed from ``IMPORT=``
rules. Use this method to create device objects in Python scripts
called from udev rules.
``context`` is the library :class:`Context`.
Return a :class:`Device` object constructed from the environment.
Raise :exc:`DeviceNotFoundInEnvironmentError`, if no device could be
created from the environment.
.. udevversion:: 152
.. versionadded:: 0.18
)r$ Z udev_device_new_from_environmentr r% )r r r& r! r! r" �from_environment s zDevices.from_environmentc C s | j | j| j| j| jgS )z�
Return methods that obtain a :class:`Device` from a variety of
different data.
:return: a list of from_* methods.
:rtype: list of class methods
.. versionadded:: 0.18
)r8 r/ r, r# r )r r! r! r" �METHODS9 s
zDevices.METHODSN)�__name__�
__module__� __qualname__�__doc__� classmethodr# r r, r/ r8 rA rS rT rU r! r! r! r" r 7 s + + # r c @ s� e Zd ZdZedd� �Zedd� �Zedd� �Zedd � �Zed
d � �Z ed d
� �Z
dd� Z dd� Z dd� Z
edd� �Zedd� �Zedd� �ZdYdd �Zd d � Zed d � �Zed!d"� �Zed#d$� �Zed%d&� �Zed'd(� �Zed)d*� �Zed+d,� �Zed-d.� �Zed/d0� �Z ed1d2� �Z ed3d4� �Z ed5d6� �Z ed7d8� �Z ed9d:� �Z!ed;d<� �Z"ed=d>� �Z#ed?d@� �Z$dAdB� Z%dCdD� Z&dEdF� Z'dGdH� Z(dIdJ� Z)dKdL� Z*dMdN� Z+dOdP� Z,dQdR� Z-dSdT� Z.dUdV� Z/dWdX� Z0dS )Zr% a�
A single device with attached attributes and properties.
This class subclasses the ``Mapping`` ABC, providing a read-only
dictionary mapping property names to the corresponding values.
Therefore all well-known dicitionary methods and operators
(e.g. ``.keys()``, ``.items()``, ``in``) are available to access device
properties.
Aside of the properties, a device also has a set of udev-specific
attributes like the path inside ``sysfs``.
:class:`Device` objects compare equal and unequal to other devices and
to strings (based on :attr:`device_path`). However, there is no
ordering on :class:`Device` objects, and the corresponding operators
``>``, ``<``, ``<=`` and ``>=`` raise :exc:`~exceptions.TypeError`.
.. warning::
**Never** use object identity (``is`` operator) to compare
:class:`Device` objects. :mod:`pyudev` may create multiple
:class:`Device` objects for the same device. Instead compare
devices by value using ``==`` or ``!=``.
:class:`Device` objects are hashable and can therefore be used as keys
in dictionaries and sets.
They can also be given directly as ``udev_device *`` to functions wrapped
through :mod:`ctypes`.
c C s$ ddl }|jdtdd� tj||�S )zw
.. versionadded:: 0.4
.. deprecated:: 0.18
Use :class:`Devices.from_path` instead.
r Nz>Will be removed in 1.0. Use equivalent Devices method instead.� )�
stacklevel)�warnings�warn�DeprecationWarningr r# )r r r r] r! r! r" r# n s zDevice.from_pathc C s$ ddl }|jdtdd� tj||�S )a|
.. versionchanged:: 0.4
Raise :exc:`NoSuchDeviceError` instead of returning ``None``, if
no device was found for ``sys_path``.
.. versionchanged:: 0.5
Raise :exc:`DeviceNotFoundAtPathError` instead of
:exc:`NoSuchDeviceError`.
.. deprecated:: 0.18
Use :class:`Devices.from_sys_path` instead.
r Nz>Will be removed in 1.0. Use equivalent Devices method instead.r[ )r\ )r] r^ r_ r r )r r r r] r! r! r" r } s zDevice.from_sys_pathc C s& ddl }|jdtdd� tj|||�S )zw
.. versionadded:: 0.5
.. deprecated:: 0.18
Use :class:`Devices.from_name` instead.
r Nz>Will be removed in 1.0. Use equivalent Devices method instead.r[ )r\ )r] r^ r_ r r, )r r r* r+ r] r! r! r" r, � s zDevice.from_namec C s& ddl }|jdtdd� tj|||�S )z�
.. versionadded:: 0.11
.. deprecated:: 0.18
Use :class:`Devices.from_device_number` instead.
r Nz>Will be removed in 1.0. Use equivalent Devices method instead.r[ )r\ )r] r^ r_ r r/ )r r r- r. r] r! r! r" r/ � s zDevice.from_device_numberc C s$ ddl }|jdtdd� tj||�S )z
.. versionadded:: 0.15
.. deprecated:: 0.18
Use :class:`Devices.from_device_file` instead.
r Nz>Will be removed in 1.0. Use equivalent Devices method instead.r[ )r\ )r] r^ r_ r r8 )r r r4 r] r! r! r" r8 � s zDevice.from_device_filec C s" ddl }|jdtdd� tj|�S )z~
.. versionadded:: 0.6
.. deprecated:: 0.18
Use :class:`Devices.from_environment` instead.
r Nz>Will be removed in 1.0. Use equivalent Devices method instead.r[ )r\ )r] r^ r_ r rT )r r r] r! r! r" rT � s zDevice.from_environmentc C s || _ || _|j| _d S )N)r Z_as_parameter_r$ )�selfr Z_devicer! r! r" �__init__� s zDevice.__init__c C s | j j| � d S )N)r$ Zudev_device_unref)r` r! r! r" �__del__� s zDevice.__del__c C s
dj | �S )NzDevice({0.sys_path!r}))�format)r` r! r! r" �__repr__� s zDevice.__repr__c C s( | j j| �}|sdS t| j| j j|��S )z_
The parent :class:`Device` or ``None``, if there is no parent
device.
N)r$ Zudev_device_get_parentr% r �udev_device_ref)r` �parentr! r! r" rf � s z
Device.parentc c s, x&| j j� j| �D ]}|| kr|V qW dS )a�
Yield all direct children of this device.
.. note::
In udev, parent-child relationships are generally ambiguous, i.e.
a parent can have multiple children, *and* a child can have multiple
parents. Hence, `child.parent == parent` does generally *not* hold
for all `child` objects in `parent.children`. In other words,
the :attr:`parent` of a device in this property can be different
from this device!
.. note::
As the underlying library does not provide any means to directly
query the children of a device, this property performs a linear
search through all devices.
Return an iterable yielding a :class:`Device` object for each direct
child of this device.
.. udevversion:: 172
.. versionchanged:: 0.13
Requires udev version 172 now.
N)r r? Z match_parent)r` r& r! r! r" �children� s zDevice.childrenc c s$ | j }x|dk r |V |j }qW dS )z�
Yield all ancestors of this device from bottom to top.
Return an iterator yielding a :class:`Device` object for each
ancestor of this device from bottom to top.
.. versionadded:: 0.16
N)rf )r` rf r! r! r" � ancestors s
zDevice.ancestorsNc C sD t |�}|dk rt |�}| jj| ||�}|s0dS t| j| jj|��S )a�
Find the parent device with the given ``subsystem`` and
``device_type``.
``subsystem`` is a byte or unicode string containing the name of the
subsystem, in which to search for the parent. ``device_type`` is a
byte or unicode string holding the expected device type of the parent.
It can be ``None`` (the default), which means, that no specific device
type is expected.
Return a parent :class:`Device` within the given ``subsystem`` and, if
``device_type`` is not ``None``, with the given ``device_type``, or
``None``, if this device has no parent device matching these
constraints.
.. versionadded:: 0.9
N)r r$ Z-udev_device_get_parent_with_subsystem_devtyper% r re )r` r* r5 rf r! r! r" � find_parent s
zDevice.find_parentc C s ddl }|jdtdd� | jS )a~
Traverse all parent devices of this device from bottom to top.
Return an iterable yielding all parent devices as :class:`Device`
objects, *not* including the current device. The last yielded
:class:`Device` is the top of the device hierarchy.
.. deprecated:: 0.16
Will be removed in 1.0. Use :attr:`ancestors` instead.
r Nz5Will be removed in 1.0. Use Device.ancestors instead.r[ )r\ )r] r^ r_ rh )r` r] r! r! r" �traverse0 s zDevice.traversec C s t | jj| ��S )zz
Absolute path of this device in ``sysfs`` including the ``sysfs``
mount point as unicode string.
)r r$ Zudev_device_get_syspath)r` r! r! r" r C s zDevice.sys_pathc C s t | jj| ��S )a
Kernel device path as unicode string. This path uniquely identifies
a single device.
Unlike :attr:`sys_path`, this path does not contain the ``sysfs``
mount point. However, the path is absolute and starts with a slash
``'/'``.
)r r$ Zudev_device_get_devpath)r` r! r! r" � device_pathL s
zDevice.device_pathc C s | j j| �}|dkrdS t|�S )z�
Name of the subsystem this device is part of as unicode string.
:returns: name of subsystem if found, else None
:rtype: unicode string or NoneType
N)r$ Zudev_device_get_subsystemr )r` Zsubsysr! r! r" r* Y s zDevice.subsystemc C s t | jj| ��S )zF
Device file name inside ``sysfs`` as unicode string.
)r r$ Zudev_device_get_sysname)r` r! r! r" r+ d s zDevice.sys_namec C s | j j| �}|dk r t|�S dS )a�
The trailing number of the :attr:`sys_name` as unicode string, or
``None``, if the device has no trailing number in its name.
.. note::
The number is returned as unicode string to preserve the exact
format of the number, especially any leading zeros:
>>> from pyudev import Context, Device
>>> context = Context()
>>> device = Devices.from_path(context, '/sys/devices/LNXSYSTM:00')
>>> device.sys_number
u'00'
To work with numbers, explicitly convert them to ints:
>>> int(device.sys_number)
0
.. versionadded:: 0.11
N)r$ Zudev_device_get_sysnumr )r` r. r! r! r" �
sys_numberl s zDevice.sys_numberc C s$ | j j| �}|dk r t|�S |S dS )a�
Device type as unicode string, or ``None``, if the device type is
unknown.
>>> from pyudev import Context
>>> context = Context()
>>> for device in context.list_devices(subsystem='net'):
... '{0} - {1}'.format(device.sys_name, device.device_type or 'ethernet')
...
u'eth0 - ethernet'
u'wlan0 - wlan'
u'lo - ethernet'
u'vboxnet0 - ethernet'
.. versionadded:: 0.10
N)r$ Zudev_device_get_devtyper )r` r5 r! r! r" r5 � s zDevice.device_typec C s | j j| �}|dk r t|�S dS )z�
The driver name as unicode string, or ``None``, if there is no
driver for this device.
.. versionadded:: 0.5
N)r$ Zudev_device_get_driverr )r` �driverr! r! r" rm � s z
Device.driverc C s | j j| �}|dk r t|�S dS )a�
Absolute path to the device node of this device as unicode string or
``None``, if this device doesn't have a device node. The path
includes the device directory (see :attr:`Context.device_path`).
This path always points to the actual device node associated with
this device, and never to any symbolic links to this device node.
See :attr:`device_links` to get a list of symbolic links to this
device node.
.. warning::
For devices created with :meth:`from_device_file()`, the value of
this property is not necessary equal to the ``filename`` given to
:meth:`from_device_file()`.
N)r$ Zudev_device_get_devnoder )r` Znoder! r! r" � device_node� s zDevice.device_nodec C s | j j| �S )a
The device number of the associated device as integer, or ``0``, if no
device number is associated.
Use :func:`os.major` and :func:`os.minor` to decompose the device
number into its major and minor number:
>>> import os
>>> from pyudev import Context, Device
>>> context = Context()
>>> sda = Devices.from_name(context, 'block', 'sda')
>>> sda.device_number
2048L
>>> (os.major(sda.device_number), os.minor(sda.device_number))
(8, 0)
For devices with an associated :attr:`device_node`, this is the same as
the ``st_rdev`` field of the stat result of the :attr:`device_node`:
>>> os.stat(sda.device_node).st_rdev
2048
.. versionadded:: 0.11
)r$ Zudev_device_get_devnum)r` r! r! r" r6 � s zDevice.device_numberc C s t | jj| ��S )ai
``True``, if the device is initialized, ``False`` otherwise.
A device is initialized, if udev has already handled this device and
has set up device node permissions and context, or renamed a network
device.
Consequently, this property is only implemented for devices with a
device node or for network devices. On all other devices this property
is always ``True``.
It is *not* recommended, that you use uninitialized devices.
.. seealso:: :attr:`time_since_initialized`
.. udevversion:: 165
.. versionadded:: 0.8
)�boolr$ Z udev_device_get_is_initialized)r` r! r! r" �is_initialized� s zDevice.is_initializedc C s | j j| �}t|d�S )a�
The time elapsed since initialization as :class:`~datetime.timedelta`.
This property is only implemented on devices, which need to store
properties in the udev database. On all other devices this property is
simply zero :class:`~datetime.timedelta`.
.. seealso:: :attr:`is_initialized`
.. udevversion:: 165
.. versionadded:: 0.8
)� microseconds)r$ Z&udev_device_get_usec_since_initializedr )r` rq r! r! r" �time_since_initialized� s z Device.time_since_initializedc c s4 | j j| �}x"t| j |�D ]\}}t|�V qW dS )a�
An iterator, which yields the absolute paths (including the device
directory, see :attr:`Context.device_path`) of all symbolic links
pointing to the :attr:`device_node` of this device. The paths are
unicode strings.
UDev can create symlinks to the original device node (see
:attr:`device_node`) inside the device directory. This is often
used to assign a constant, fixed device node to devices like
removeable media, which technically do not have a constant device
node, or to map a single device into multiple device hierarchies.
The property provides access to all such symbolic links, which were
created by UDev for this device.
.. warning::
Links are not necessarily resolved by
:meth:`Devices.from_device_file()`. Hence do *not* rely on
``Devices.from_device_file(context, link).device_path ==
device.device_path`` from any ``link`` in ``device.device_links``.
N)r$ Z#udev_device_get_devlinks_list_entryr r )r` Zdevlinks�namerR r! r! r" � device_links s zDevice.device_linksc C s | j j| �}|dk r t|�S dS )a
The device event action as string, or ``None``, if this device was not
received from a :class:`Monitor`.
Usual actions are:
``'add'``
A device has been added (e.g. a USB device was plugged in)
``'remove'``
A device has been removed (e.g. a USB device was unplugged)
``'change'``
Something about the device changed (e.g. a device property)
``'online'``
The device is online now
``'offline'``
The device is offline now
.. warning::
Though the actions listed above are the most common, this property
*may* return other values, too, so be prepared to handle unknown
actions!
.. versionadded:: 0.16
N)r$ Zudev_device_get_actionr )r` �actionr! r! r" ru s z
Device.actionc C s | j j| �S )z�
The device event sequence number as integer, or ``0`` if this device
has no sequence number, i.e. was not received from a :class:`Monitor`.
.. versionadded:: 0.16
)r$ Zudev_device_get_seqnum)r` r! r! r" �sequence_number> s zDevice.sequence_numberc C s t | �S )aT
The system attributes of this device as read-only
:class:`Attributes` mapping.
System attributes are basically normal files inside the the device
directory. These files contain all sorts of information about the
device, which may not be reflected by properties. These attributes
are commonly used for matching in udev rules, and can be printed
using ``udevadm info --attribute-walk``.
The values of these attributes are not always proper strings, and
can contain arbitrary bytes.
.. versionadded:: 0.5
)�
Attributes)r` r! r! r" r: H s zDevice.attributesc C s t | �S )zu
The udev properties of this object as read-only Properties mapping.
.. versionadded:: 0.21
)�
Properties)r` r! r! r" �
properties_ s zDevice.propertiesc C s t | �S )a�
A :class:`Tags` object representing the tags attached to this device.
The :class:`Tags` object supports a test for a single tag as well as
iteration over all tags:
>>> from pyudev import Context
>>> context = Context()
>>> device = next(iter(context.list_devices(tag='systemd')))
>>> 'systemd' in device.tags
True
>>> list(device.tags)
[u'seat', u'systemd', u'uaccess']
Tags are arbitrary classifiers that can be attached to devices by udev
scripts and daemons. For instance, systemd_ uses tags for multi-seat_
support.
.. _systemd: http://freedesktop.org/wiki/Software/systemd
.. _multi-seat: http://www.freedesktop.org/wiki/Software/systemd/multiseat
.. udevversion:: 154
.. versionadded:: 0.6
.. versionchanged:: 0.13
Return a :class:`Tags` object now.
)�Tags)r` r! r! r" �tagsh s z Device.tagsc C s" ddl }|jdtdd� | jj� S )a*
Iterate over the names of all properties defined for this device.
Return a generator yielding the names of all properties of this
device as unicode strings.
.. deprecated:: 0.21
Will be removed in 1.0. Access properties with Device.properties.
r NzAWill be removed in 1.0. Access properties with Device.properties.r[ )r\ )r] r^ r_ ry �__iter__)r` r] r! r! r" r| � s
zDevice.__iter__c C s" ddl }|jdtdd� | jj� S )z�
Return the amount of properties defined for this device as integer.
.. deprecated:: 0.21
Will be removed in 1.0. Access properties with Device.properties.
r NzAWill be removed in 1.0. Access properties with Device.properties.r[ )r\ )r] r^ r_ ry �__len__)r` r] r! r! r" r} � s zDevice.__len__c C s$ ddl }|jdtdd� | jj|�S )a�
Get the given property from this device.
``prop`` is a unicode or byte string containing the name of the
property.
Return the property value as unicode string, or raise a
:exc:`~exceptions.KeyError`, if the given property is not defined
for this device.
.. deprecated:: 0.21
Will be removed in 1.0. Access properties with Device.properties.
r NzAWill be removed in 1.0. Access properties with Device.properties.r[ )r\ )r] r^ r_ ry � __getitem__)r` �propr] r! r! r" r~ � s zDevice.__getitem__c C s$ ddl }|jdtdd� | jj|�S )a
Get the given property from this device as integer.
``prop`` is a unicode or byte string containing the name of the
property.
Return the property value as integer. Raise a
:exc:`~exceptions.KeyError`, if the given property is not defined
for this device, or a :exc:`~exceptions.ValueError`, if the property
value cannot be converted to an integer.
.. deprecated:: 0.21
Will be removed in 1.0. Use Device.properties.asint() instead.
r Nz<Will be removed in 1.0. Use Device.properties.asint instead.r[ )r\ )r] r^ r_ ry �asint)r` r r] r! r! r" r� � s z Device.asintc C s$ ddl }|jdtdd� | jj|�S )a�
Get the given property from this device as boolean.
A boolean property has either a value of ``'1'`` or of ``'0'``,
where ``'1'`` stands for ``True``, and ``'0'`` for ``False``. Any
other value causes a :exc:`~exceptions.ValueError` to be raised.
``prop`` is a unicode or byte string containing the name of the
property.
Return ``True``, if the property value is ``'1'`` and ``False``, if
the property value is ``'0'``. Any other value raises a
:exc:`~exceptions.ValueError`. Raise a :exc:`~exceptions.KeyError`,
if the given property is not defined for this device.
.. deprecated:: 0.21
Will be removed in 1.0. Use Device.properties.asbool() instead.
r Nz=Will be removed in 1.0. Use Device.properties.asbool instead.r[ )r\ )r] r^ r_ ry �asbool)r` r r] r! r! r" r� � s z
Device.asboolc C s
t | j�S )N)�hashrk )r` r! r! r" �__hash__� s zDevice.__hash__c C s$ t |t�r| j|jkS | j|kS d S )N)�
isinstancer% rk )r` �otherr! r! r" �__eq__� s
z
Device.__eq__c C s$ t |t�r| j|jkS | j|kS d S )N)r� r% rk )r` r� r! r! r" �__ne__� s
z
Device.__ne__c C s t d��d S )NzDevice not orderable)� TypeError)r` r� r! r! r" �__gt__ s z
Device.__gt__c C s t d��d S )NzDevice not orderable)r� )r` r� r! r! r" �__lt__ s z
Device.__lt__c C s t d��d S )NzDevice not orderable)r� )r` r� r! r! r" �__le__ s z
Device.__le__c C s t d��d S )NzDevice not orderable)r� )r` r� r! r! r" �__ge__ s z
Device.__ge__)N)1rV rW rX rY rZ r# r r, r/ r8 rT ra rb rd �propertyrf rg rh ri rj r rk r* r+ rl r5 rm rn r6 rp rr rt ru rv r: ry r{ r| r} r~ r� r� r� r� r� r� r� r� r� r! r! r! r" r% M sX
r% c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dS )rx zN
udev properties :class:`Device` objects.
.. versionadded:: 0.21
c C s || _ |j| _d S )N)r& r$ )r` r& r! r! r" ra s zProperties.__init__c c s6 | j j| j�}x"t| j |�D ]\}}t|�V q W dS )z�
Iterate over the names of all properties defined for the device.
Return a generator yielding the names of all properties of this
device as unicode strings.
N)r$ �%udev_device_get_properties_list_entryr& r r )r` ry rs rR r! r! r" r| s zProperties.__iter__c C s( | j j| j�}tdd� t| j |�D ��S )zU
Return the amount of properties defined for this device as integer.
c s s | ]
}d V qdS )rB Nr! )r< rR r! r! r" r> * s z%Properties.__len__.<locals>.<genexpr>)r$ r� r& �sumr )r` ry r! r! r" r} $ s zProperties.__len__c C s, | j j| jt|��}|dkr$t|��t|�S )a9
Get the given property from this device.
``prop`` is a unicode or byte string containing the name of the
property.
Return the property value as unicode string, or raise a
:exc:`~exceptions.KeyError`, if the given property is not defined
for this device.
N)r$ Z udev_device_get_property_valuer& r �KeyErrorr )r` r �valuer! r! r" r~ , s
zProperties.__getitem__c C s t | | �S )a�
Get the given property from this device as integer.
``prop`` is a unicode or byte string containing the name of the
property.
Return the property value as integer. Raise a
:exc:`~exceptions.KeyError`, if the given property is not defined
for this device, or a :exc:`~exceptions.ValueError`, if the property
value cannot be converted to an integer.
)rN )r` r r! r! r" r� ? s zProperties.asintc C s t | | �S )a�
Get the given property from this device as boolean.
A boolean property has either a value of ``'1'`` or of ``'0'``,
where ``'1'`` stands for ``True``, and ``'0'`` for ``False``. Any
other value causes a :exc:`~exceptions.ValueError` to be raised.
``prop`` is a unicode or byte string containing the name of the
property.
Return ``True``, if the property value is ``'1'`` and ``False``, if
the property value is ``'0'``. Any other value raises a
:exc:`~exceptions.ValueError`. Raise a :exc:`~exceptions.KeyError`,
if the given property is not defined for this device.
)r )r` r r! r! r" r� M s zProperties.asboolN)
rV rW rX rY ra r| r} r~ r� r� r! r! r! r" rx
s rx c @ sN e Zd ZdZdd� Zedd� �Zdd� Zdd d
�Zd d � Z d
d� Z
dd� Z dS )rw zQ
udev attributes for :class:`Device` objects.
.. versionadded:: 0.5
c C s || _ |j| _d S )N)r& r$ )r` r& r! r! r" ra g s zAttributes.__init__c c sF t | jd�sdS | jj| j�}x"t| j|�D ]\}}t|�V q,W dS )a�
Yield the ``available`` attributes for the device.
It is not guaranteed that a key in this list will have a value.
It is not guaranteed that a key not in this list will not have a value.
It is guaranteed that the keys in this list are the keys that libudev
considers to be "available" attributes.
If libudev version does not define udev_device_get_sysattr_list_entry()
yields nothing.
See rhbz#1267584.
�"udev_device_get_sysattr_list_entryN)�hasattrr$ r� r& r r )r` �attrs� attributerR r! r! r" �available_attributesk s
z Attributes.available_attributesc C s( | j j| jt|��}|dkr$t|��|S )aD
Get the given system ``attribute`` for the device.
:param attribute: the key for an attribute value
:type attribute: unicode or byte string
:returns: the value corresponding to ``attribute``
:rtype: an arbitrary sequence of bytes
:raises KeyError: if no value found
N)r$ Z udev_device_get_sysattr_valuer& r r� )r` r� r� r! r! r" �_get� s
zAttributes._getNc C s$ y
| j |�S tk
r |S X dS )a|
Get the given system ``attribute`` for the device.
:param attribute: the key for an attribute value
:type attribute: unicode or byte string
:param default: a default if no corresponding value found
:type default: a sequence of bytes
:returns: the value corresponding to ``attribute`` or ``default``
:rtype: object
N)r� r� )r` r� �defaultr! r! r" r; � s
zAttributes.getc C s t | j|��S )a�
Get the given ``attribute`` for the device as unicode string.
:param attribute: the key for an attribute value
:type attribute: unicode or byte string
:returns: the value corresponding to ``attribute``, as unicode
:rtype: unicode
:raises KeyError: if no value found for ``attribute``
:raises UnicodeDecodeError: if value is not convertible
)r r� )r` r� r! r! r" �asstring� s zAttributes.asstringc C s t | j|��S )a�
Get the given ``attribute`` as an int.
:param attribute: the key for an attribute value
:type attribute: unicode or byte string
:returns: the value corresponding to ``attribute``, as an int
:rtype: int
:raises KeyError: if no value found for ``attribute``
:raises UnicodeDecodeError: if value is not convertible to unicode
:raises ValueError: if unicode value can not be converted to an int
)rN r� )r` r� r! r! r" r� � s zAttributes.asintc C s t | j|��S )a�
Get the given ``attribute`` from this device as a bool.
:param attribute: the key for an attribute value
:type attribute: unicode or byte string
:returns: the value corresponding to ``attribute``, as bool
:rtype: bool
:raises KeyError: if no value found for ``attribute``
:raises UnicodeDecodeError: if value is not convertible to unicode
:raises ValueError: if unicode value can not be converted to a bool
A boolean attribute has either a value of ``'1'`` or of ``'0'``,
where ``'1'`` stands for ``True``, and ``'0'`` for ``False``. Any
other value causes a :exc:`~exceptions.ValueError` to be raised.
)r r� )r` r� r! r! r" r� � s zAttributes.asbool)N) rV rW rX rY ra r� r� r� r; r� r� r� r! r! r! r" rw ` s
rw c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
S ) rz zk
A iterable over :class:`Device` tags.
Subclasses the ``Container`` and the ``Iterable`` ABC.
c C s || _ |j| _d S )N)r& r$ )r` r& r! r! r" ra � s z
Tags.__init__c s> t | jd�r$t| jj| jt� ���S t� fdd�| D ��S dS )z
Whether ``tag`` exists.
:param tag: unicode string with name of tag
:rtype: bool
�udev_device_has_tagc 3 s | ]}|� kV qd S )Nr! )r< �t)�tagr! r" r> � s z Tags._has_tag.<locals>.<genexpr>N)r� r$ ro r� r& r �any)r` r� r! )r� r" �_has_tag� s z
Tags._has_tagc C s
| j |�S )z�
Check for existence of ``tag``.
``tag`` is a tag as unicode string.
Return ``True``, if ``tag`` is attached to the device, ``False``
otherwise.
)r� )r` r� r! r! r" � __contains__� s zTags.__contains__c c s6 | j j| j�}x"t| j |�D ]\}}t|�V q W dS )zS
Iterate over all tags.
Yield each tag as unicode string.
N)r$ Z udev_device_get_tags_list_entryr& r r )r` r{ r� rR r! r! r" r| � s z
Tags.__iter__N)rV rW rX rY ra r� r� r| r! r! r! r" rz � s
rz )"rY Z
__future__r r r r r rJ � collectionsr r r Zdatetimer Zpyudev.device._errorsr
r r r
r r r Z pyudev._utilr r r r r �objectr r% rx rw rz r! r! r! r" �<module> sD ESq device/__pycache__/_errors.cpython-36.opt-1.pyc 0000644 00000014370 15035142005 0015253 0 ustar 00 3
5�Vl � @ s d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlmZ eej �G dd � d e
��Z eej �G d
d � d e ��Z G d d
� d
e �Z
G dd� de �ZG dd� de �ZG dd� de �ZG dd� de �ZG dd� de �ZG dd� de �ZG dd� de �ZdS ) z�
pyudev.device._errors
=====================
Errors raised by Device methods.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literalsN)�
add_metaclassc @ s e Zd ZdZdS )� DeviceErrorzP
Any error raised when messing around w/ or trying to discover devices.
N)�__name__�
__module__� __qualname__�__doc__� r r � /usr/lib/python3.6/_errors.pyr $ s r c @ s e Zd ZdZdS )�DeviceNotFoundErrorz�
An exception indicating that no :class:`Device` was found.
.. versionchanged:: 0.5
Rename from ``NoSuchDeviceError`` to its current name.
N)r r r
r r r r r
r + s r c @ s, e Zd ZdZdd� Zedd� �Zdd� ZdS ) �DeviceNotFoundAtPathErrorzh
A :exc:`DeviceNotFoundError` indicating that no :class:`Device` was
found at a given path.
c C s t j| |� d S )N)r �__init__)�self�sys_pathr r r
r ; s z"DeviceNotFoundAtPathError.__init__c C s
| j d S )z<
The path that caused this error as string.
r )�args)r r r r
r > s z"DeviceNotFoundAtPathError.sys_pathc C s dj | j�S )NzNo device at {0!r})�formatr )r r r r
�__str__E s z!DeviceNotFoundAtPathError.__str__N)r r r
r r �propertyr r r r r r
r 5 s r c @ s e Zd ZdZdS )�DeviceNotFoundByFileErrorzp
A :exc:`DeviceNotFoundError` indicating that no :class:`Device` was
found from the given filename.
N)r r r
r r r r r
r I s r c @ s e Zd ZdZdS )�#DeviceNotFoundByInterfaceIndexErrorzw
A :exc:`DeviceNotFoundError` indicating that no :class:`Device` was found
from the given interface index.
N)r r r
r r r r r
r O s r c @ s e Zd ZdZdS )�!DeviceNotFoundByKernelDeviceErrorz�
A :exc:`DeviceNotFoundError` indicating that no :class:`Device` was found
from the given kernel device string.
The format of the kernel device string is defined in the
systemd.journal-fields man pagees.
N)r r r
r r r r r
r U s r c @ s8 e Zd ZdZdd� Zedd� �Zedd� �Zdd � Zd
S ) �DeviceNotFoundByNameErrorzj
A :exc:`DeviceNotFoundError` indicating that no :class:`Device` was
found with a given name.
c C s t j| ||� d S )N)r r )r � subsystem�sys_namer r r
r e s z"DeviceNotFoundByNameError.__init__c C s
| j d S )zA
The subsystem that caused this error as string.
r )r )r r r r
r h s z#DeviceNotFoundByNameError.subsystemc C s
| j d S )z@
The sys name that caused this error as string.
� )r )r r r r
r o s z"DeviceNotFoundByNameError.sys_namec C s
dj | �S )Nz+No device {0.sys_name!r} in {0.subsystem!r})r )r r r r
r v s z!DeviceNotFoundByNameError.__str__N) r r r
r r r r r r r r r r
r _ s
r c @ s8 e Zd ZdZdd� Zedd� �Zedd� �Zdd � Zd
S ) �DeviceNotFoundByNumberErrorzs
A :exc:`DeviceNotFoundError` indicating, that no :class:`Device` was found
for a given device number.
c C s t j| ||� d S )N)r r )r �typZnumberr r r
r � s z$DeviceNotFoundByNumberError.__init__c C s
| j d S )zj
The device type causing this error as string. Either ``'char'`` or
``'block'``.
r )r )r r r r
� device_type� s z'DeviceNotFoundByNumberError.device_typec C s
| j d S )zB
The device number causing this error as integer.
r )r )r r r r
�
device_number� s z)DeviceNotFoundByNumberError.device_numberc C s
dj | �S )Nz7No {0.device_type} device with number {0.device_number})r )r r r r
r � s z#DeviceNotFoundByNumberError.__str__N) r r r
r r r r r! r r r r r
r z s
r c @ s e Zd ZdZdd� ZdS )� DeviceNotFoundInEnvironmentErrorz�
A :exc:`DeviceNotFoundError` indicating, that no :class:`Device` could
be constructed from the process environment.
c C s dS )Nz No device found in environmentr )r r r r
r � s z(DeviceNotFoundInEnvironmentError.__str__N)r r r
r r r r r r
r" � s r" c @ s& e Zd ZdZdZddd�Zdd� ZdS ) �DeviceValueErrorz�
Raised when a parameter has an unacceptable value.
May also be raised when the parameter has an unacceptable type.
z+value '%s' for parameter %s is unacceptableNc C s || _ || _|| _dS )z� Initializer.
:param object value: the value
:param str param: the parameter
:param str msg: an explanatory message
N)�_value�_param�_msg)r �valueZparam�msgr r r
r � s zDeviceValueError.__init__c C s: | j r$| jd }|| j| j| j f S | j| j| jf S d S )Nz: %s)r& �_FMT_STRr$ r% )r Zfmt_strr r r
r � s
zDeviceValueError.__str__)N)r r r
r r) r r r r r r
r# � s
r# )r Z
__future__r r r r �abcZsixr �ABCMeta� Exceptionr r r r r r r r r" r# r r r r
�<module> s$
device/__pycache__/_device.cpython-36.pyc 0000644 00000124641 15035142005 0014242 0 ustar 00 3
u1�Wɭ � @ sZ d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlZddlm Z ddlm
Z
dd lm Z dd
l m
Z
dd lmZ dd lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ G dd� de �Z G dd� de �Z G dd � d e �Z G d d � d e �Z G d d � d e
e �Z!dS )!z�
pyudev.device._device
=====================
Device class implementation of :mod:`pyudev`.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literalsN)� Container)�Iterable)�Mapping)� timedelta)�DeviceNotFoundAtPathError)�DeviceNotFoundByFileError)�#DeviceNotFoundByInterfaceIndexError)�!DeviceNotFoundByKernelDeviceError)�DeviceNotFoundByNameError)�DeviceNotFoundByNumberError)� DeviceNotFoundInEnvironmentError)�ensure_byte_string)�ensure_unicode_string)�get_device_type)�string_to_bool)�udev_list_iteratec @ s| e Zd ZdZedd� �Zedd� �Zedd� �Zedd � �Zed
d � �Z ed d
� �Z
edd� �Z edd� �Z edd� �Z
dS )�DeviceszT
Class for constructing :class:`Device` objects from various kinds of data.
c C s0 |j |j�s$tjj|j|jtj��}| j||�S )a�
Create a device from a device ``path``. The ``path`` may or may not
start with the ``sysfs`` mount point:
>>> from pyudev import Context, Device
>>> context = Context()
>>> Devices.from_path(context, '/devices/platform')
Device(u'/sys/devices/platform')
>>> Devices.from_path(context, '/sys/devices/platform')
Device(u'/sys/devices/platform')
``context`` is the :class:`Context` in which to search the device.
``path`` is a device path as unicode or byte string.
Return a :class:`Device` object for the device. Raise
:exc:`DeviceNotFoundAtPathError`, if no device was found for ``path``.
.. versionadded:: 0.18
)�
startswith�sys_path�os�path�join�lstrip�sep�
from_sys_path)�cls�contextr � r! � /usr/lib/python3.6/_device.py� from_path< s zDevices.from_pathc C s( |j j|t|��}|s t|��t||�S )a�
Create a new device from a given ``sys_path``:
>>> from pyudev import Context, Device
>>> context = Context()
>>> Devices.from_sys_path(context, '/sys/devices/platform')
Device(u'/sys/devices/platform')
``context`` is the :class:`Context` in which to search the device.
``sys_path`` is a unicode or byte string containing the path of the
device inside ``sysfs`` with the mount point included.
Return a :class:`Device` object for the device. Raise
:exc:`DeviceNotFoundAtPathError`, if no device was found for
``sys_path``.
.. versionadded:: 0.18
)�_libudevZ udev_device_new_from_syspathr r
�Device)r r r �devicer! r! r" r U s
zDevices.from_sys_pathc C s< |j dd�}|jj|t|�t|��}|s2t||��t||�S )a.
Create a new device from a given ``subsystem`` and a given
``sys_name``:
>>> from pyudev import Context, Device
>>> context = Context()
>>> sda = Devices.from_name(context, 'block', 'sda')
>>> sda
Device(u'/sys/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0/block/sda')
>>> sda == Devices.from_path(context, '/block/sda')
``context`` is the :class:`Context` in which to search the device.
``subsystem`` and ``sys_name`` are byte or unicode strings, which
denote the subsystem and the name of the device to create.
Return a :class:`Device` object for the device. Raise
:exc:`DeviceNotFoundByNameError`, if no device was found with the given
name.
.. versionadded:: 0.18
�/�!)�replacer$ Z&udev_device_new_from_subsystem_sysnamer r r% )r r � subsystem�sys_namer& r! r! r" � from_nameo s
zDevices.from_namec C s0 |j j|t|d �|�}|s&t||��t||�S )a�
Create a new device from a device ``number`` with the given device
``type``:
>>> import os
>>> from pyudev import Context, Device
>>> ctx = Context()
>>> major, minor = 8, 0
>>> device = Devices.from_device_number(context, 'block',
... os.makedev(major, minor))
>>> device
Device(u'/sys/devices/pci0000:00/0000:00:11.0/host0/target0:0:0/0:0:0:0/block/sda')
>>> os.major(device.device_number), os.minor(device.device_number)
(8, 0)
Use :func:`os.makedev` to construct a device number from a major and a
minor device number, as shown in the example above.
.. warning::
Device numbers are not unique across different device types.
Passing a correct number with a wrong type may silently yield a
wrong device object, so make sure to pass the correct device type.
``context`` is the :class:`Context`, in which to search the device.
``type`` is either ``'char'`` or ``'block'``, according to whether the
device is a character or block device. ``number`` is the device number
as integer.
Return a :class:`Device` object for the device with the given device
``number``. Raise :exc:`DeviceNotFoundByNumberError`, if no device was
found with the given device type and number.
.. versionadded:: 0.18
r )r$ Zudev_device_new_from_devnumr r r% )r r �typ�numberr& r! r! r" �from_device_number� s
%
zDevices.from_device_numberc C sV yt |�}tj|�j}W n. ttfk
rF } zt|��W Y dd}~X nX | j|||�S )a�
Create a new device from the given device file:
>>> from pyudev import Context, Device
>>> context = Context()
>>> device = Devices.from_device_file(context, '/dev/sda')
>>> device
Device(u'/sys/devices/pci0000:00/0000:00:0d.0/host2/target2:0:0/2:0:0:0/block/sda')
>>> device.device_node
u'/dev/sda'
.. warning::
Though the example seems to suggest that ``device.device_node ==
filename`` holds with ``device = Devices.from_device_file(context,
filename)``, this is only true in a majority of cases. There *can*
be devices, for which this relation is actually false! Thus, do
*not* expect :attr:`~Device.device_node` to be equal to the given
``filename`` for the returned :class:`Device`. Especially, use
:attr:`~Device.device_node` if you need the device file of a
:class:`Device` created with this method afterwards.
``context`` is the :class:`Context` in which to search the device.
``filename`` is a string containing the path of a device file.
Return a :class:`Device` representing the given device file. Raise
:exc:`DeviceNotFoundByFileError` if ``filename`` is no device file
at all or if ``filename`` does not exist or if its metadata was
inaccessible.
.. versionadded:: 0.18
N)r r �stat�st_rdev�EnvironmentError�
ValueErrorr r/ )r r �filename� device_type�
device_number�errr! r! r" �from_device_file� s "zDevices.from_device_filec s< |j dd�}t� fdd�|D �d�}|dk r0|S t� ��dS )a?
Locate a device based on the interface index.
:param `Context` context: the libudev context
:param int ifindex: the interface index
:returns: the device corresponding to the interface index
:rtype: `Device`
This method is only appropriate for network devices.
Znet)r* c 3 s" | ]}|j jd �� kr|V qdS )�ifindexN)�
attributes�get)�.0�d)r9 r! r" � <genexpr>� s z/Devices.from_interface_index.<locals>.<genexpr>N)� list_devices�nextr )r r r9 Znetwork_devicesZdevr! )r9 r" �from_interface_index� s z Devices.from_interface_indexc C s� |d }|dd� }|d krlt jd�}|j|�}|rbtjt|jd��t|jd���}| j|||�S t|��nT|d kr�| j ||�S |d
kr�|j
d �\}} }
|
r�|r�| j |||
�S t|��nt|��dS )
a
Locate a device based on the kernel device.
:param `Context` context: the libudev context
:param str kernel_device: the kernel device
:returns: the device corresponding to ``kernel_device``
:rtype: `Device`
r � N�b�cz ^(?P<major>\d+):(?P<minor>\d+)$�major�minor�n�+�:)rC rD ) �re�compile�matchr �makedev�int�groupr/ r
rA � partitionr, ) r r Z
kernel_deviceZ switch_char�restZ number_rerL r. r* �_Zkernel_device_namer! r! r" �from_kernel_device� s&
zDevices.from_kernel_devicec C s |j j|�}|st� �t||�S )a�
Create a new device from the process environment (as in
:data:`os.environ`).
This only works reliable, if the current process is called from an
udev rule, and is usually used for tools executed from ``IMPORT=``
rules. Use this method to create device objects in Python scripts
called from udev rules.
``context`` is the library :class:`Context`.
Return a :class:`Device` object constructed from the environment.
Raise :exc:`DeviceNotFoundInEnvironmentError`, if no device could be
created from the environment.
.. udevversion:: 152
.. versionadded:: 0.18
)r$ Z udev_device_new_from_environmentr r% )r r r& r! r! r" �from_environment s zDevices.from_environmentc C s | j | j| j| j| jgS )z�
Return methods that obtain a :class:`Device` from a variety of
different data.
:return: a list of from_* methods.
:rtype: list of class methods
.. versionadded:: 0.18
)r8 r/ r, r# r )r r! r! r" �METHODS9 s
zDevices.METHODSN)�__name__�
__module__� __qualname__�__doc__� classmethodr# r r, r/ r8 rA rS rT rU r! r! r! r" r 7 s + + # r c @ s� e Zd ZdZedd� �Zedd� �Zedd� �Zedd � �Zed
d � �Z ed d
� �Z
dd� Z dd� Z dd� Z
edd� �Zedd� �Zedd� �ZdYdd �Zd d � Zed d � �Zed!d"� �Zed#d$� �Zed%d&� �Zed'd(� �Zed)d*� �Zed+d,� �Zed-d.� �Zed/d0� �Z ed1d2� �Z ed3d4� �Z ed5d6� �Z ed7d8� �Z ed9d:� �Z!ed;d<� �Z"ed=d>� �Z#ed?d@� �Z$dAdB� Z%dCdD� Z&dEdF� Z'dGdH� Z(dIdJ� Z)dKdL� Z*dMdN� Z+dOdP� Z,dQdR� Z-dSdT� Z.dUdV� Z/dWdX� Z0dS )Zr% a�
A single device with attached attributes and properties.
This class subclasses the ``Mapping`` ABC, providing a read-only
dictionary mapping property names to the corresponding values.
Therefore all well-known dicitionary methods and operators
(e.g. ``.keys()``, ``.items()``, ``in``) are available to access device
properties.
Aside of the properties, a device also has a set of udev-specific
attributes like the path inside ``sysfs``.
:class:`Device` objects compare equal and unequal to other devices and
to strings (based on :attr:`device_path`). However, there is no
ordering on :class:`Device` objects, and the corresponding operators
``>``, ``<``, ``<=`` and ``>=`` raise :exc:`~exceptions.TypeError`.
.. warning::
**Never** use object identity (``is`` operator) to compare
:class:`Device` objects. :mod:`pyudev` may create multiple
:class:`Device` objects for the same device. Instead compare
devices by value using ``==`` or ``!=``.
:class:`Device` objects are hashable and can therefore be used as keys
in dictionaries and sets.
They can also be given directly as ``udev_device *`` to functions wrapped
through :mod:`ctypes`.
c C s$ ddl }|jdtdd� tj||�S )zw
.. versionadded:: 0.4
.. deprecated:: 0.18
Use :class:`Devices.from_path` instead.
r Nz>Will be removed in 1.0. Use equivalent Devices method instead.� )�
stacklevel)�warnings�warn�DeprecationWarningr r# )r r r r] r! r! r" r# n s zDevice.from_pathc C s$ ddl }|jdtdd� tj||�S )a|
.. versionchanged:: 0.4
Raise :exc:`NoSuchDeviceError` instead of returning ``None``, if
no device was found for ``sys_path``.
.. versionchanged:: 0.5
Raise :exc:`DeviceNotFoundAtPathError` instead of
:exc:`NoSuchDeviceError`.
.. deprecated:: 0.18
Use :class:`Devices.from_sys_path` instead.
r Nz>Will be removed in 1.0. Use equivalent Devices method instead.r[ )r\ )r] r^ r_ r r )r r r r] r! r! r" r } s zDevice.from_sys_pathc C s& ddl }|jdtdd� tj|||�S )zw
.. versionadded:: 0.5
.. deprecated:: 0.18
Use :class:`Devices.from_name` instead.
r Nz>Will be removed in 1.0. Use equivalent Devices method instead.r[ )r\ )r] r^ r_ r r, )r r r* r+ r] r! r! r" r, � s zDevice.from_namec C s& ddl }|jdtdd� tj|||�S )z�
.. versionadded:: 0.11
.. deprecated:: 0.18
Use :class:`Devices.from_device_number` instead.
r Nz>Will be removed in 1.0. Use equivalent Devices method instead.r[ )r\ )r] r^ r_ r r/ )r r r- r. r] r! r! r" r/ � s zDevice.from_device_numberc C s$ ddl }|jdtdd� tj||�S )z
.. versionadded:: 0.15
.. deprecated:: 0.18
Use :class:`Devices.from_device_file` instead.
r Nz>Will be removed in 1.0. Use equivalent Devices method instead.r[ )r\ )r] r^ r_ r r8 )r r r4 r] r! r! r" r8 � s zDevice.from_device_filec C s" ddl }|jdtdd� tj|�S )z~
.. versionadded:: 0.6
.. deprecated:: 0.18
Use :class:`Devices.from_environment` instead.
r Nz>Will be removed in 1.0. Use equivalent Devices method instead.r[ )r\ )r] r^ r_ r rT )r r r] r! r! r" rT � s zDevice.from_environmentc C s || _ || _|j| _d S )N)r Z_as_parameter_r$ )�selfr Z_devicer! r! r" �__init__� s zDevice.__init__c C s | j j| � d S )N)r$ Zudev_device_unref)r` r! r! r" �__del__� s zDevice.__del__c C s
dj | �S )NzDevice({0.sys_path!r}))�format)r` r! r! r" �__repr__� s zDevice.__repr__c C s( | j j| �}|sdS t| j| j j|��S )z_
The parent :class:`Device` or ``None``, if there is no parent
device.
N)r$ Zudev_device_get_parentr% r �udev_device_ref)r` �parentr! r! r" rf � s z
Device.parentc c s, x&| j j� j| �D ]}|| kr|V qW dS )a�
Yield all direct children of this device.
.. note::
In udev, parent-child relationships are generally ambiguous, i.e.
a parent can have multiple children, *and* a child can have multiple
parents. Hence, `child.parent == parent` does generally *not* hold
for all `child` objects in `parent.children`. In other words,
the :attr:`parent` of a device in this property can be different
from this device!
.. note::
As the underlying library does not provide any means to directly
query the children of a device, this property performs a linear
search through all devices.
Return an iterable yielding a :class:`Device` object for each direct
child of this device.
.. udevversion:: 172
.. versionchanged:: 0.13
Requires udev version 172 now.
N)r r? Z match_parent)r` r& r! r! r" �children� s zDevice.childrenc c s$ | j }x|dk r |V |j }qW dS )z�
Yield all ancestors of this device from bottom to top.
Return an iterator yielding a :class:`Device` object for each
ancestor of this device from bottom to top.
.. versionadded:: 0.16
N)rf )r` rf r! r! r" � ancestors s
zDevice.ancestorsNc C sD t |�}|dk rt |�}| jj| ||�}|s0dS t| j| jj|��S )a�
Find the parent device with the given ``subsystem`` and
``device_type``.
``subsystem`` is a byte or unicode string containing the name of the
subsystem, in which to search for the parent. ``device_type`` is a
byte or unicode string holding the expected device type of the parent.
It can be ``None`` (the default), which means, that no specific device
type is expected.
Return a parent :class:`Device` within the given ``subsystem`` and, if
``device_type`` is not ``None``, with the given ``device_type``, or
``None``, if this device has no parent device matching these
constraints.
.. versionadded:: 0.9
N)r r$ Z-udev_device_get_parent_with_subsystem_devtyper% r re )r` r* r5 rf r! r! r" � find_parent s
zDevice.find_parentc C s ddl }|jdtdd� | jS )a~
Traverse all parent devices of this device from bottom to top.
Return an iterable yielding all parent devices as :class:`Device`
objects, *not* including the current device. The last yielded
:class:`Device` is the top of the device hierarchy.
.. deprecated:: 0.16
Will be removed in 1.0. Use :attr:`ancestors` instead.
r Nz5Will be removed in 1.0. Use Device.ancestors instead.r[ )r\ )r] r^ r_ rh )r` r] r! r! r" �traverse0 s zDevice.traversec C s t | jj| ��S )zz
Absolute path of this device in ``sysfs`` including the ``sysfs``
mount point as unicode string.
)r r$ Zudev_device_get_syspath)r` r! r! r" r C s zDevice.sys_pathc C s t | jj| ��S )a
Kernel device path as unicode string. This path uniquely identifies
a single device.
Unlike :attr:`sys_path`, this path does not contain the ``sysfs``
mount point. However, the path is absolute and starts with a slash
``'/'``.
)r r$ Zudev_device_get_devpath)r` r! r! r" � device_pathL s
zDevice.device_pathc C s | j j| �}|dkrdS t|�S )z�
Name of the subsystem this device is part of as unicode string.
:returns: name of subsystem if found, else None
:rtype: unicode string or NoneType
N)r$ Zudev_device_get_subsystemr )r` Zsubsysr! r! r" r* Y s zDevice.subsystemc C s t | jj| ��S )zF
Device file name inside ``sysfs`` as unicode string.
)r r$ Zudev_device_get_sysname)r` r! r! r" r+ d s zDevice.sys_namec C s | j j| �}|dk r t|�S dS )a�
The trailing number of the :attr:`sys_name` as unicode string, or
``None``, if the device has no trailing number in its name.
.. note::
The number is returned as unicode string to preserve the exact
format of the number, especially any leading zeros:
>>> from pyudev import Context, Device
>>> context = Context()
>>> device = Devices.from_path(context, '/sys/devices/LNXSYSTM:00')
>>> device.sys_number
u'00'
To work with numbers, explicitly convert them to ints:
>>> int(device.sys_number)
0
.. versionadded:: 0.11
N)r$ Zudev_device_get_sysnumr )r` r. r! r! r" �
sys_numberl s zDevice.sys_numberc C s$ | j j| �}|dk r t|�S |S dS )a�
Device type as unicode string, or ``None``, if the device type is
unknown.
>>> from pyudev import Context
>>> context = Context()
>>> for device in context.list_devices(subsystem='net'):
... '{0} - {1}'.format(device.sys_name, device.device_type or 'ethernet')
...
u'eth0 - ethernet'
u'wlan0 - wlan'
u'lo - ethernet'
u'vboxnet0 - ethernet'
.. versionadded:: 0.10
N)r$ Zudev_device_get_devtyper )r` r5 r! r! r" r5 � s zDevice.device_typec C s | j j| �}|dk r t|�S dS )z�
The driver name as unicode string, or ``None``, if there is no
driver for this device.
.. versionadded:: 0.5
N)r$ Zudev_device_get_driverr )r` �driverr! r! r" rm � s z
Device.driverc C s | j j| �}|dk r t|�S dS )a�
Absolute path to the device node of this device as unicode string or
``None``, if this device doesn't have a device node. The path
includes the device directory (see :attr:`Context.device_path`).
This path always points to the actual device node associated with
this device, and never to any symbolic links to this device node.
See :attr:`device_links` to get a list of symbolic links to this
device node.
.. warning::
For devices created with :meth:`from_device_file()`, the value of
this property is not necessary equal to the ``filename`` given to
:meth:`from_device_file()`.
N)r$ Zudev_device_get_devnoder )r` Znoder! r! r" � device_node� s zDevice.device_nodec C s | j j| �S )a
The device number of the associated device as integer, or ``0``, if no
device number is associated.
Use :func:`os.major` and :func:`os.minor` to decompose the device
number into its major and minor number:
>>> import os
>>> from pyudev import Context, Device
>>> context = Context()
>>> sda = Devices.from_name(context, 'block', 'sda')
>>> sda.device_number
2048L
>>> (os.major(sda.device_number), os.minor(sda.device_number))
(8, 0)
For devices with an associated :attr:`device_node`, this is the same as
the ``st_rdev`` field of the stat result of the :attr:`device_node`:
>>> os.stat(sda.device_node).st_rdev
2048
.. versionadded:: 0.11
)r$ Zudev_device_get_devnum)r` r! r! r" r6 � s zDevice.device_numberc C s t | jj| ��S )ai
``True``, if the device is initialized, ``False`` otherwise.
A device is initialized, if udev has already handled this device and
has set up device node permissions and context, or renamed a network
device.
Consequently, this property is only implemented for devices with a
device node or for network devices. On all other devices this property
is always ``True``.
It is *not* recommended, that you use uninitialized devices.
.. seealso:: :attr:`time_since_initialized`
.. udevversion:: 165
.. versionadded:: 0.8
)�boolr$ Z udev_device_get_is_initialized)r` r! r! r" �is_initialized� s zDevice.is_initializedc C s | j j| �}t|d�S )a�
The time elapsed since initialization as :class:`~datetime.timedelta`.
This property is only implemented on devices, which need to store
properties in the udev database. On all other devices this property is
simply zero :class:`~datetime.timedelta`.
.. seealso:: :attr:`is_initialized`
.. udevversion:: 165
.. versionadded:: 0.8
)� microseconds)r$ Z&udev_device_get_usec_since_initializedr )r` rq r! r! r" �time_since_initialized� s z Device.time_since_initializedc c s4 | j j| �}x"t| j |�D ]\}}t|�V qW dS )a�
An iterator, which yields the absolute paths (including the device
directory, see :attr:`Context.device_path`) of all symbolic links
pointing to the :attr:`device_node` of this device. The paths are
unicode strings.
UDev can create symlinks to the original device node (see
:attr:`device_node`) inside the device directory. This is often
used to assign a constant, fixed device node to devices like
removeable media, which technically do not have a constant device
node, or to map a single device into multiple device hierarchies.
The property provides access to all such symbolic links, which were
created by UDev for this device.
.. warning::
Links are not necessarily resolved by
:meth:`Devices.from_device_file()`. Hence do *not* rely on
``Devices.from_device_file(context, link).device_path ==
device.device_path`` from any ``link`` in ``device.device_links``.
N)r$ Z#udev_device_get_devlinks_list_entryr r )r` Zdevlinks�namerR r! r! r" � device_links s zDevice.device_linksc C s | j j| �}|dk r t|�S dS )a
The device event action as string, or ``None``, if this device was not
received from a :class:`Monitor`.
Usual actions are:
``'add'``
A device has been added (e.g. a USB device was plugged in)
``'remove'``
A device has been removed (e.g. a USB device was unplugged)
``'change'``
Something about the device changed (e.g. a device property)
``'online'``
The device is online now
``'offline'``
The device is offline now
.. warning::
Though the actions listed above are the most common, this property
*may* return other values, too, so be prepared to handle unknown
actions!
.. versionadded:: 0.16
N)r$ Zudev_device_get_actionr )r` �actionr! r! r" ru s z
Device.actionc C s | j j| �S )z�
The device event sequence number as integer, or ``0`` if this device
has no sequence number, i.e. was not received from a :class:`Monitor`.
.. versionadded:: 0.16
)r$ Zudev_device_get_seqnum)r` r! r! r" �sequence_number> s zDevice.sequence_numberc C s t | �S )aT
The system attributes of this device as read-only
:class:`Attributes` mapping.
System attributes are basically normal files inside the the device
directory. These files contain all sorts of information about the
device, which may not be reflected by properties. These attributes
are commonly used for matching in udev rules, and can be printed
using ``udevadm info --attribute-walk``.
The values of these attributes are not always proper strings, and
can contain arbitrary bytes.
.. versionadded:: 0.5
)�
Attributes)r` r! r! r" r: H s zDevice.attributesc C s t | �S )zu
The udev properties of this object as read-only Properties mapping.
.. versionadded:: 0.21
)�
Properties)r` r! r! r" �
properties_ s zDevice.propertiesc C s t | �S )a�
A :class:`Tags` object representing the tags attached to this device.
The :class:`Tags` object supports a test for a single tag as well as
iteration over all tags:
>>> from pyudev import Context
>>> context = Context()
>>> device = next(iter(context.list_devices(tag='systemd')))
>>> 'systemd' in device.tags
True
>>> list(device.tags)
[u'seat', u'systemd', u'uaccess']
Tags are arbitrary classifiers that can be attached to devices by udev
scripts and daemons. For instance, systemd_ uses tags for multi-seat_
support.
.. _systemd: http://freedesktop.org/wiki/Software/systemd
.. _multi-seat: http://www.freedesktop.org/wiki/Software/systemd/multiseat
.. udevversion:: 154
.. versionadded:: 0.6
.. versionchanged:: 0.13
Return a :class:`Tags` object now.
)�Tags)r` r! r! r" �tagsh s z Device.tagsc C s" ddl }|jdtdd� | jj� S )a*
Iterate over the names of all properties defined for this device.
Return a generator yielding the names of all properties of this
device as unicode strings.
.. deprecated:: 0.21
Will be removed in 1.0. Access properties with Device.properties.
r NzAWill be removed in 1.0. Access properties with Device.properties.r[ )r\ )r] r^ r_ ry �__iter__)r` r] r! r! r" r| � s
zDevice.__iter__c C s" ddl }|jdtdd� | jj� S )z�
Return the amount of properties defined for this device as integer.
.. deprecated:: 0.21
Will be removed in 1.0. Access properties with Device.properties.
r NzAWill be removed in 1.0. Access properties with Device.properties.r[ )r\ )r] r^ r_ ry �__len__)r` r] r! r! r" r} � s zDevice.__len__c C s$ ddl }|jdtdd� | jj|�S )a�
Get the given property from this device.
``prop`` is a unicode or byte string containing the name of the
property.
Return the property value as unicode string, or raise a
:exc:`~exceptions.KeyError`, if the given property is not defined
for this device.
.. deprecated:: 0.21
Will be removed in 1.0. Access properties with Device.properties.
r NzAWill be removed in 1.0. Access properties with Device.properties.r[ )r\ )r] r^ r_ ry � __getitem__)r` �propr] r! r! r" r~ � s zDevice.__getitem__c C s$ ddl }|jdtdd� | jj|�S )a
Get the given property from this device as integer.
``prop`` is a unicode or byte string containing the name of the
property.
Return the property value as integer. Raise a
:exc:`~exceptions.KeyError`, if the given property is not defined
for this device, or a :exc:`~exceptions.ValueError`, if the property
value cannot be converted to an integer.
.. deprecated:: 0.21
Will be removed in 1.0. Use Device.properties.asint() instead.
r Nz<Will be removed in 1.0. Use Device.properties.asint instead.r[ )r\ )r] r^ r_ ry �asint)r` r r] r! r! r" r� � s z Device.asintc C s$ ddl }|jdtdd� | jj|�S )a�
Get the given property from this device as boolean.
A boolean property has either a value of ``'1'`` or of ``'0'``,
where ``'1'`` stands for ``True``, and ``'0'`` for ``False``. Any
other value causes a :exc:`~exceptions.ValueError` to be raised.
``prop`` is a unicode or byte string containing the name of the
property.
Return ``True``, if the property value is ``'1'`` and ``False``, if
the property value is ``'0'``. Any other value raises a
:exc:`~exceptions.ValueError`. Raise a :exc:`~exceptions.KeyError`,
if the given property is not defined for this device.
.. deprecated:: 0.21
Will be removed in 1.0. Use Device.properties.asbool() instead.
r Nz=Will be removed in 1.0. Use Device.properties.asbool instead.r[ )r\ )r] r^ r_ ry �asbool)r` r r] r! r! r" r� � s z
Device.asboolc C s
t | j�S )N)�hashrk )r` r! r! r" �__hash__� s zDevice.__hash__c C s$ t |t�r| j|jkS | j|kS d S )N)�
isinstancer% rk )r` �otherr! r! r" �__eq__� s
z
Device.__eq__c C s$ t |t�r| j|jkS | j|kS d S )N)r� r% rk )r` r� r! r! r" �__ne__� s
z
Device.__ne__c C s t d��d S )NzDevice not orderable)� TypeError)r` r� r! r! r" �__gt__ s z
Device.__gt__c C s t d��d S )NzDevice not orderable)r� )r` r� r! r! r" �__lt__ s z
Device.__lt__c C s t d��d S )NzDevice not orderable)r� )r` r� r! r! r" �__le__ s z
Device.__le__c C s t d��d S )NzDevice not orderable)r� )r` r� r! r! r" �__ge__ s z
Device.__ge__)N)1rV rW rX rY rZ r# r r, r/ r8 rT ra rb rd �propertyrf rg rh ri rj r rk r* r+ rl r5 rm rn r6 rp rr rt ru rv r: ry r{ r| r} r~ r� r� r� r� r� r� r� r� r� r! r! r! r" r% M sX
r% c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dS )rx zN
udev properties :class:`Device` objects.
.. versionadded:: 0.21
c C s || _ |j| _d S )N)r& r$ )r` r& r! r! r" ra s zProperties.__init__c c s6 | j j| j�}x"t| j |�D ]\}}t|�V q W dS )z�
Iterate over the names of all properties defined for the device.
Return a generator yielding the names of all properties of this
device as unicode strings.
N)r$ �%udev_device_get_properties_list_entryr& r r )r` ry rs rR r! r! r" r| s zProperties.__iter__c C s( | j j| j�}tdd� t| j |�D ��S )zU
Return the amount of properties defined for this device as integer.
c s s | ]
}d V qdS )rB Nr! )r< rR r! r! r" r> * s z%Properties.__len__.<locals>.<genexpr>)r$ r� r& �sumr )r` ry r! r! r" r} $ s zProperties.__len__c C s, | j j| jt|��}|dkr$t|��t|�S )a9
Get the given property from this device.
``prop`` is a unicode or byte string containing the name of the
property.
Return the property value as unicode string, or raise a
:exc:`~exceptions.KeyError`, if the given property is not defined
for this device.
N)r$ Z udev_device_get_property_valuer& r �KeyErrorr )r` r �valuer! r! r" r~ , s
zProperties.__getitem__c C s t | | �S )a�
Get the given property from this device as integer.
``prop`` is a unicode or byte string containing the name of the
property.
Return the property value as integer. Raise a
:exc:`~exceptions.KeyError`, if the given property is not defined
for this device, or a :exc:`~exceptions.ValueError`, if the property
value cannot be converted to an integer.
)rN )r` r r! r! r" r� ? s zProperties.asintc C s t | | �S )a�
Get the given property from this device as boolean.
A boolean property has either a value of ``'1'`` or of ``'0'``,
where ``'1'`` stands for ``True``, and ``'0'`` for ``False``. Any
other value causes a :exc:`~exceptions.ValueError` to be raised.
``prop`` is a unicode or byte string containing the name of the
property.
Return ``True``, if the property value is ``'1'`` and ``False``, if
the property value is ``'0'``. Any other value raises a
:exc:`~exceptions.ValueError`. Raise a :exc:`~exceptions.KeyError`,
if the given property is not defined for this device.
)r )r` r r! r! r" r� M s zProperties.asboolN)
rV rW rX rY ra r| r} r~ r� r� r! r! r! r" rx
s rx c @ sN e Zd ZdZdd� Zedd� �Zdd� Zdd d
�Zd d � Z d
d� Z
dd� Z dS )rw zQ
udev attributes for :class:`Device` objects.
.. versionadded:: 0.5
c C s || _ |j| _d S )N)r& r$ )r` r& r! r! r" ra g s zAttributes.__init__c c sF t | jd�sdS | jj| j�}x"t| j|�D ]\}}t|�V q,W dS )a�
Yield the ``available`` attributes for the device.
It is not guaranteed that a key in this list will have a value.
It is not guaranteed that a key not in this list will not have a value.
It is guaranteed that the keys in this list are the keys that libudev
considers to be "available" attributes.
If libudev version does not define udev_device_get_sysattr_list_entry()
yields nothing.
See rhbz#1267584.
�"udev_device_get_sysattr_list_entryN)�hasattrr$ r� r& r r )r` �attrs� attributerR r! r! r" �available_attributesk s
z Attributes.available_attributesc C s( | j j| jt|��}|dkr$t|��|S )aD
Get the given system ``attribute`` for the device.
:param attribute: the key for an attribute value
:type attribute: unicode or byte string
:returns: the value corresponding to ``attribute``
:rtype: an arbitrary sequence of bytes
:raises KeyError: if no value found
N)r$ Z udev_device_get_sysattr_valuer& r r� )r` r� r� r! r! r" �_get� s
zAttributes._getNc C s$ y
| j |�S tk
r |S X dS )a|
Get the given system ``attribute`` for the device.
:param attribute: the key for an attribute value
:type attribute: unicode or byte string
:param default: a default if no corresponding value found
:type default: a sequence of bytes
:returns: the value corresponding to ``attribute`` or ``default``
:rtype: object
N)r� r� )r` r� �defaultr! r! r" r; � s
zAttributes.getc C s t | j|��S )a�
Get the given ``attribute`` for the device as unicode string.
:param attribute: the key for an attribute value
:type attribute: unicode or byte string
:returns: the value corresponding to ``attribute``, as unicode
:rtype: unicode
:raises KeyError: if no value found for ``attribute``
:raises UnicodeDecodeError: if value is not convertible
)r r� )r` r� r! r! r" �asstring� s zAttributes.asstringc C s t | j|��S )a�
Get the given ``attribute`` as an int.
:param attribute: the key for an attribute value
:type attribute: unicode or byte string
:returns: the value corresponding to ``attribute``, as an int
:rtype: int
:raises KeyError: if no value found for ``attribute``
:raises UnicodeDecodeError: if value is not convertible to unicode
:raises ValueError: if unicode value can not be converted to an int
)rN r� )r` r� r! r! r" r� � s zAttributes.asintc C s t | j|��S )a�
Get the given ``attribute`` from this device as a bool.
:param attribute: the key for an attribute value
:type attribute: unicode or byte string
:returns: the value corresponding to ``attribute``, as bool
:rtype: bool
:raises KeyError: if no value found for ``attribute``
:raises UnicodeDecodeError: if value is not convertible to unicode
:raises ValueError: if unicode value can not be converted to a bool
A boolean attribute has either a value of ``'1'`` or of ``'0'``,
where ``'1'`` stands for ``True``, and ``'0'`` for ``False``. Any
other value causes a :exc:`~exceptions.ValueError` to be raised.
)r r� )r` r� r! r! r" r� � s zAttributes.asbool)N) rV rW rX rY ra r� r� r� r; r� r� r� r! r! r! r" rw ` s
rw c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
S ) rz zk
A iterable over :class:`Device` tags.
Subclasses the ``Container`` and the ``Iterable`` ABC.
c C s || _ |j| _d S )N)r& r$ )r` r& r! r! r" ra � s z
Tags.__init__c s> t | jd�r$t| jj| jt� ���S t� fdd�| D ��S dS )z
Whether ``tag`` exists.
:param tag: unicode string with name of tag
:rtype: bool
�udev_device_has_tagc 3 s | ]}|� kV qd S )Nr! )r< �t)�tagr! r" r> � s z Tags._has_tag.<locals>.<genexpr>N)r� r$ ro r� r& r �any)r` r� r! )r� r" �_has_tag� s z
Tags._has_tagc C s
| j |�S )z�
Check for existence of ``tag``.
``tag`` is a tag as unicode string.
Return ``True``, if ``tag`` is attached to the device, ``False``
otherwise.
)r� )r` r� r! r! r" � __contains__� s zTags.__contains__c c s6 | j j| j�}x"t| j |�D ]\}}t|�V q W dS )zS
Iterate over all tags.
Yield each tag as unicode string.
N)r$ Z udev_device_get_tags_list_entryr& r r )r` r{ r� rR r! r! r" r| � s z
Tags.__iter__N)rV rW rX rY ra r� r� r| r! r! r! r" rz � s
rz )"rY Z
__future__r r r r r rJ � collectionsr r r Zdatetimer Zpyudev.device._errorsr
r r r
r r r Z pyudev._utilr r r r r �objectr r% rx rw rz r! r! r! r" �<module> sD ESq device/__pycache__/__init__.cpython-36.pyc 0000644 00000001307 15035142005 0014374 0 ustar 00 3
N�#WO � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z dd lm
Z
dd
lm Z dd lm Z d S )
z�
pyudev.device
=============
Device class implementation of :mod:`pyudev`.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�
Attributes)�Device)�Devices)�Tags)�DeviceNotFoundAtPathError)�DeviceNotFoundByFileError)�DeviceNotFoundByNameError)�DeviceNotFoundByNumberError)�DeviceNotFoundError)� DeviceNotFoundInEnvironmentErrorN)
�__doc__Z_devicer r r r Z_errorsr r r r r
r � r
r
� /usr/lib/python3.6/__init__.py�<module> s device/__pycache__/_errors.cpython-36.pyc 0000644 00000014370 15035142005 0014314 0 ustar 00 3
5�Vl � @ s d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlmZ eej �G dd � d e
��Z eej �G d
d � d e ��Z G d d
� d
e �Z
G dd� de �ZG dd� de �ZG dd� de �ZG dd� de �ZG dd� de �ZG dd� de �ZG dd� de �ZdS ) z�
pyudev.device._errors
=====================
Errors raised by Device methods.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�absolute_import)�division)�print_function)�unicode_literalsN)�
add_metaclassc @ s e Zd ZdZdS )� DeviceErrorzP
Any error raised when messing around w/ or trying to discover devices.
N)�__name__�
__module__� __qualname__�__doc__� r r � /usr/lib/python3.6/_errors.pyr $ s r c @ s e Zd ZdZdS )�DeviceNotFoundErrorz�
An exception indicating that no :class:`Device` was found.
.. versionchanged:: 0.5
Rename from ``NoSuchDeviceError`` to its current name.
N)r r r
r r r r r
r + s r c @ s, e Zd ZdZdd� Zedd� �Zdd� ZdS ) �DeviceNotFoundAtPathErrorzh
A :exc:`DeviceNotFoundError` indicating that no :class:`Device` was
found at a given path.
c C s t j| |� d S )N)r �__init__)�self�sys_pathr r r
r ; s z"DeviceNotFoundAtPathError.__init__c C s
| j d S )z<
The path that caused this error as string.
r )�args)r r r r
r > s z"DeviceNotFoundAtPathError.sys_pathc C s dj | j�S )NzNo device at {0!r})�formatr )r r r r
�__str__E s z!DeviceNotFoundAtPathError.__str__N)r r r
r r �propertyr r r r r r
r 5 s r c @ s e Zd ZdZdS )�DeviceNotFoundByFileErrorzp
A :exc:`DeviceNotFoundError` indicating that no :class:`Device` was
found from the given filename.
N)r r r
r r r r r
r I s r c @ s e Zd ZdZdS )�#DeviceNotFoundByInterfaceIndexErrorzw
A :exc:`DeviceNotFoundError` indicating that no :class:`Device` was found
from the given interface index.
N)r r r
r r r r r
r O s r c @ s e Zd ZdZdS )�!DeviceNotFoundByKernelDeviceErrorz�
A :exc:`DeviceNotFoundError` indicating that no :class:`Device` was found
from the given kernel device string.
The format of the kernel device string is defined in the
systemd.journal-fields man pagees.
N)r r r
r r r r r
r U s r c @ s8 e Zd ZdZdd� Zedd� �Zedd� �Zdd � Zd
S ) �DeviceNotFoundByNameErrorzj
A :exc:`DeviceNotFoundError` indicating that no :class:`Device` was
found with a given name.
c C s t j| ||� d S )N)r r )r � subsystem�sys_namer r r
r e s z"DeviceNotFoundByNameError.__init__c C s
| j d S )zA
The subsystem that caused this error as string.
r )r )r r r r
r h s z#DeviceNotFoundByNameError.subsystemc C s
| j d S )z@
The sys name that caused this error as string.
� )r )r r r r
r o s z"DeviceNotFoundByNameError.sys_namec C s
dj | �S )Nz+No device {0.sys_name!r} in {0.subsystem!r})r )r r r r
r v s z!DeviceNotFoundByNameError.__str__N) r r r
r r r r r r r r r r
r _ s
r c @ s8 e Zd ZdZdd� Zedd� �Zedd� �Zdd � Zd
S ) �DeviceNotFoundByNumberErrorzs
A :exc:`DeviceNotFoundError` indicating, that no :class:`Device` was found
for a given device number.
c C s t j| ||� d S )N)r r )r �typZnumberr r r
r � s z$DeviceNotFoundByNumberError.__init__c C s
| j d S )zj
The device type causing this error as string. Either ``'char'`` or
``'block'``.
r )r )r r r r
� device_type� s z'DeviceNotFoundByNumberError.device_typec C s
| j d S )zB
The device number causing this error as integer.
r )r )r r r r
�
device_number� s z)DeviceNotFoundByNumberError.device_numberc C s
dj | �S )Nz7No {0.device_type} device with number {0.device_number})r )r r r r
r � s z#DeviceNotFoundByNumberError.__str__N) r r r
r r r r r! r r r r r
r z s
r c @ s e Zd ZdZdd� ZdS )� DeviceNotFoundInEnvironmentErrorz�
A :exc:`DeviceNotFoundError` indicating, that no :class:`Device` could
be constructed from the process environment.
c C s dS )Nz No device found in environmentr )r r r r
r � s z(DeviceNotFoundInEnvironmentError.__str__N)r r r
r r r r r r
r" � s r" c @ s& e Zd ZdZdZddd�Zdd� ZdS ) �DeviceValueErrorz�
Raised when a parameter has an unacceptable value.
May also be raised when the parameter has an unacceptable type.
z+value '%s' for parameter %s is unacceptableNc C s || _ || _|| _dS )z� Initializer.
:param object value: the value
:param str param: the parameter
:param str msg: an explanatory message
N)�_value�_param�_msg)r �valueZparam�msgr r r
r � s zDeviceValueError.__init__c C s: | j r$| jd }|| j| j| j f S | j| j| jf S d S )Nz: %s)r& �_FMT_STRr$ r% )r Zfmt_strr r r
r � s
zDeviceValueError.__str__)N)r r r
r r) r r r r r r
r# � s
r# )r Z
__future__r r r r �abcZsixr �ABCMeta� Exceptionr r r r r r r r r" r# r r r r
�<module> s$
device/__pycache__/__init__.cpython-36.opt-1.pyc 0000644 00000001307 15035142005 0015333 0 ustar 00 3
N�#WO � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z dd lm
Z
dd
lm Z dd lm Z d S )
z�
pyudev.device
=============
Device class implementation of :mod:`pyudev`.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
� )�
Attributes)�Device)�Devices)�Tags)�DeviceNotFoundAtPathError)�DeviceNotFoundByFileError)�DeviceNotFoundByNameError)�DeviceNotFoundByNumberError)�DeviceNotFoundError)� DeviceNotFoundInEnvironmentErrorN)
�__doc__Z_devicer r r r Z_errorsr r r r r
r � r
r
� /usr/lib/python3.6/__init__.py�<module> s device/_device.py 0000644 00000126711 15035142005 0007756 0 ustar 00 # -*- coding: utf-8 -*-
# Copyright (C) 2011, 2012 Sebastian Wiesner <lunaryorn@gmail.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
pyudev.device._device
=====================
Device class implementation of :mod:`pyudev`.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@gmail.com>
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import os
import re
from collections import Container
from collections import Iterable
from collections import Mapping
from datetime import timedelta
from pyudev.device._errors import DeviceNotFoundAtPathError
from pyudev.device._errors import DeviceNotFoundByFileError
from pyudev.device._errors import DeviceNotFoundByInterfaceIndexError
from pyudev.device._errors import DeviceNotFoundByKernelDeviceError
from pyudev.device._errors import DeviceNotFoundByNameError
from pyudev.device._errors import DeviceNotFoundByNumberError
from pyudev.device._errors import DeviceNotFoundInEnvironmentError
from pyudev._util import ensure_byte_string
from pyudev._util import ensure_unicode_string
from pyudev._util import get_device_type
from pyudev._util import string_to_bool
from pyudev._util import udev_list_iterate
# pylint: disable=too-many-lines
class Devices(object):
"""
Class for constructing :class:`Device` objects from various kinds of data.
"""
@classmethod
def from_path(cls, context, path):
"""
Create a device from a device ``path``. The ``path`` may or may not
start with the ``sysfs`` mount point:
>>> from pyudev import Context, Device
>>> context = Context()
>>> Devices.from_path(context, '/devices/platform')
Device(u'/sys/devices/platform')
>>> Devices.from_path(context, '/sys/devices/platform')
Device(u'/sys/devices/platform')
``context`` is the :class:`Context` in which to search the device.
``path`` is a device path as unicode or byte string.
Return a :class:`Device` object for the device. Raise
:exc:`DeviceNotFoundAtPathError`, if no device was found for ``path``.
.. versionadded:: 0.18
"""
if not path.startswith(context.sys_path):
path = os.path.join(context.sys_path, path.lstrip(os.sep))
return cls.from_sys_path(context, path)
@classmethod
def from_sys_path(cls, context, sys_path):
"""
Create a new device from a given ``sys_path``:
>>> from pyudev import Context, Device
>>> context = Context()
>>> Devices.from_sys_path(context, '/sys/devices/platform')
Device(u'/sys/devices/platform')
``context`` is the :class:`Context` in which to search the device.
``sys_path`` is a unicode or byte string containing the path of the
device inside ``sysfs`` with the mount point included.
Return a :class:`Device` object for the device. Raise
:exc:`DeviceNotFoundAtPathError`, if no device was found for
``sys_path``.
.. versionadded:: 0.18
"""
device = context._libudev.udev_device_new_from_syspath(
context, ensure_byte_string(sys_path))
if not device:
raise DeviceNotFoundAtPathError(sys_path)
return Device(context, device)
@classmethod
def from_name(cls, context, subsystem, sys_name):
"""
Create a new device from a given ``subsystem`` and a given
``sys_name``:
>>> from pyudev import Context, Device
>>> context = Context()
>>> sda = Devices.from_name(context, 'block', 'sda')
>>> sda
Device(u'/sys/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0/block/sda')
>>> sda == Devices.from_path(context, '/block/sda')
``context`` is the :class:`Context` in which to search the device.
``subsystem`` and ``sys_name`` are byte or unicode strings, which
denote the subsystem and the name of the device to create.
Return a :class:`Device` object for the device. Raise
:exc:`DeviceNotFoundByNameError`, if no device was found with the given
name.
.. versionadded:: 0.18
"""
sys_name = sys_name.replace("/", "!")
device = context._libudev.udev_device_new_from_subsystem_sysname(
context, ensure_byte_string(subsystem),
ensure_byte_string(sys_name))
if not device:
raise DeviceNotFoundByNameError(subsystem, sys_name)
return Device(context, device)
@classmethod
def from_device_number(cls, context, typ, number):
"""
Create a new device from a device ``number`` with the given device
``type``:
>>> import os
>>> from pyudev import Context, Device
>>> ctx = Context()
>>> major, minor = 8, 0
>>> device = Devices.from_device_number(context, 'block',
... os.makedev(major, minor))
>>> device
Device(u'/sys/devices/pci0000:00/0000:00:11.0/host0/target0:0:0/0:0:0:0/block/sda')
>>> os.major(device.device_number), os.minor(device.device_number)
(8, 0)
Use :func:`os.makedev` to construct a device number from a major and a
minor device number, as shown in the example above.
.. warning::
Device numbers are not unique across different device types.
Passing a correct number with a wrong type may silently yield a
wrong device object, so make sure to pass the correct device type.
``context`` is the :class:`Context`, in which to search the device.
``type`` is either ``'char'`` or ``'block'``, according to whether the
device is a character or block device. ``number`` is the device number
as integer.
Return a :class:`Device` object for the device with the given device
``number``. Raise :exc:`DeviceNotFoundByNumberError`, if no device was
found with the given device type and number.
.. versionadded:: 0.18
"""
device = context._libudev.udev_device_new_from_devnum(
context, ensure_byte_string(typ[0]), number)
if not device:
raise DeviceNotFoundByNumberError(typ, number)
return Device(context, device)
@classmethod
def from_device_file(cls, context, filename):
"""
Create a new device from the given device file:
>>> from pyudev import Context, Device
>>> context = Context()
>>> device = Devices.from_device_file(context, '/dev/sda')
>>> device
Device(u'/sys/devices/pci0000:00/0000:00:0d.0/host2/target2:0:0/2:0:0:0/block/sda')
>>> device.device_node
u'/dev/sda'
.. warning::
Though the example seems to suggest that ``device.device_node ==
filename`` holds with ``device = Devices.from_device_file(context,
filename)``, this is only true in a majority of cases. There *can*
be devices, for which this relation is actually false! Thus, do
*not* expect :attr:`~Device.device_node` to be equal to the given
``filename`` for the returned :class:`Device`. Especially, use
:attr:`~Device.device_node` if you need the device file of a
:class:`Device` created with this method afterwards.
``context`` is the :class:`Context` in which to search the device.
``filename`` is a string containing the path of a device file.
Return a :class:`Device` representing the given device file. Raise
:exc:`DeviceNotFoundByFileError` if ``filename`` is no device file
at all or if ``filename`` does not exist or if its metadata was
inaccessible.
.. versionadded:: 0.18
"""
try:
device_type = get_device_type(filename)
device_number = os.stat(filename).st_rdev
except (EnvironmentError, ValueError) as err:
raise DeviceNotFoundByFileError(err)
return cls.from_device_number(context, device_type, device_number)
@classmethod
def from_interface_index(cls, context, ifindex):
"""
Locate a device based on the interface index.
:param `Context` context: the libudev context
:param int ifindex: the interface index
:returns: the device corresponding to the interface index
:rtype: `Device`
This method is only appropriate for network devices.
"""
network_devices = context.list_devices(subsystem='net')
dev = next(
(d for d in network_devices if \
d.attributes.get('ifindex') == ifindex),
None
)
if dev is not None:
return dev
else:
raise DeviceNotFoundByInterfaceIndexError(ifindex)
@classmethod
def from_kernel_device(cls, context, kernel_device):
"""
Locate a device based on the kernel device.
:param `Context` context: the libudev context
:param str kernel_device: the kernel device
:returns: the device corresponding to ``kernel_device``
:rtype: `Device`
"""
switch_char = kernel_device[0]
rest = kernel_device[1:]
if switch_char in ('b', 'c'):
number_re = re.compile(r'^(?P<major>\d+):(?P<minor>\d+)$')
match = number_re.match(rest)
if match:
number = os.makedev(
int(match.group('major')),
int(match.group('minor'))
)
return cls.from_device_number(context, switch_char, number)
else:
raise DeviceNotFoundByKernelDeviceError(kernel_device)
elif switch_char == 'n':
return cls.from_interface_index(context, rest)
elif switch_char == '+':
(subsystem, _, kernel_device_name) = rest.partition(':')
if kernel_device_name and subsystem:
return cls.from_name(context, subsystem, kernel_device_name)
else:
raise DeviceNotFoundByKernelDeviceError(kernel_device)
else:
raise DeviceNotFoundByKernelDeviceError(kernel_device)
@classmethod
def from_environment(cls, context):
"""
Create a new device from the process environment (as in
:data:`os.environ`).
This only works reliable, if the current process is called from an
udev rule, and is usually used for tools executed from ``IMPORT=``
rules. Use this method to create device objects in Python scripts
called from udev rules.
``context`` is the library :class:`Context`.
Return a :class:`Device` object constructed from the environment.
Raise :exc:`DeviceNotFoundInEnvironmentError`, if no device could be
created from the environment.
.. udevversion:: 152
.. versionadded:: 0.18
"""
device = context._libudev.udev_device_new_from_environment(context)
if not device:
raise DeviceNotFoundInEnvironmentError()
return Device(context, device)
@classmethod
def METHODS(cls): # pylint: disable=invalid-name
"""
Return methods that obtain a :class:`Device` from a variety of
different data.
:return: a list of from_* methods.
:rtype: list of class methods
.. versionadded:: 0.18
"""
return [ #pragma: no cover
cls.from_device_file,
cls.from_device_number,
cls.from_name,
cls.from_path,
cls.from_sys_path
]
class Device(Mapping):
# pylint: disable=too-many-public-methods
"""
A single device with attached attributes and properties.
This class subclasses the ``Mapping`` ABC, providing a read-only
dictionary mapping property names to the corresponding values.
Therefore all well-known dicitionary methods and operators
(e.g. ``.keys()``, ``.items()``, ``in``) are available to access device
properties.
Aside of the properties, a device also has a set of udev-specific
attributes like the path inside ``sysfs``.
:class:`Device` objects compare equal and unequal to other devices and
to strings (based on :attr:`device_path`). However, there is no
ordering on :class:`Device` objects, and the corresponding operators
``>``, ``<``, ``<=`` and ``>=`` raise :exc:`~exceptions.TypeError`.
.. warning::
**Never** use object identity (``is`` operator) to compare
:class:`Device` objects. :mod:`pyudev` may create multiple
:class:`Device` objects for the same device. Instead compare
devices by value using ``==`` or ``!=``.
:class:`Device` objects are hashable and can therefore be used as keys
in dictionaries and sets.
They can also be given directly as ``udev_device *`` to functions wrapped
through :mod:`ctypes`.
"""
@classmethod
def from_path(cls, context, path): #pragma: no cover
"""
.. versionadded:: 0.4
.. deprecated:: 0.18
Use :class:`Devices.from_path` instead.
"""
import warnings
warnings.warn(
'Will be removed in 1.0. Use equivalent Devices method instead.',
DeprecationWarning,
stacklevel=2
)
return Devices.from_path(context, path)
@classmethod
def from_sys_path(cls, context, sys_path): #pragma: no cover
"""
.. versionchanged:: 0.4
Raise :exc:`NoSuchDeviceError` instead of returning ``None``, if
no device was found for ``sys_path``.
.. versionchanged:: 0.5
Raise :exc:`DeviceNotFoundAtPathError` instead of
:exc:`NoSuchDeviceError`.
.. deprecated:: 0.18
Use :class:`Devices.from_sys_path` instead.
"""
import warnings
warnings.warn(
'Will be removed in 1.0. Use equivalent Devices method instead.',
DeprecationWarning,
stacklevel=2
)
return Devices.from_sys_path(context, sys_path)
@classmethod
def from_name(cls, context, subsystem, sys_name): #pragma: no cover
"""
.. versionadded:: 0.5
.. deprecated:: 0.18
Use :class:`Devices.from_name` instead.
"""
import warnings
warnings.warn(
'Will be removed in 1.0. Use equivalent Devices method instead.',
DeprecationWarning,
stacklevel=2
)
return Devices.from_name(context, subsystem, sys_name)
@classmethod
def from_device_number(cls, context, typ, number): #pragma: no cover
"""
.. versionadded:: 0.11
.. deprecated:: 0.18
Use :class:`Devices.from_device_number` instead.
"""
import warnings
warnings.warn(
'Will be removed in 1.0. Use equivalent Devices method instead.',
DeprecationWarning,
stacklevel=2
)
return Devices.from_device_number(context, typ, number)
@classmethod
def from_device_file(cls, context, filename): #pragma: no cover
"""
.. versionadded:: 0.15
.. deprecated:: 0.18
Use :class:`Devices.from_device_file` instead.
"""
import warnings
warnings.warn(
'Will be removed in 1.0. Use equivalent Devices method instead.',
DeprecationWarning,
stacklevel=2
)
return Devices.from_device_file(context, filename)
@classmethod
def from_environment(cls, context): #pragma: no cover
"""
.. versionadded:: 0.6
.. deprecated:: 0.18
Use :class:`Devices.from_environment` instead.
"""
import warnings
warnings.warn(
'Will be removed in 1.0. Use equivalent Devices method instead.',
DeprecationWarning,
stacklevel=2
)
return Devices.from_environment(context)
def __init__(self, context, _device):
self.context = context
self._as_parameter_ = _device
self._libudev = context._libudev
def __del__(self):
self._libudev.udev_device_unref(self)
def __repr__(self):
return 'Device({0.sys_path!r})'.format(self)
@property
def parent(self):
"""
The parent :class:`Device` or ``None``, if there is no parent
device.
"""
parent = self._libudev.udev_device_get_parent(self)
if not parent:
return None
# the parent device is not referenced, thus forcibly acquire a
# reference
return Device(self.context, self._libudev.udev_device_ref(parent))
@property
def children(self):
"""
Yield all direct children of this device.
.. note::
In udev, parent-child relationships are generally ambiguous, i.e.
a parent can have multiple children, *and* a child can have multiple
parents. Hence, `child.parent == parent` does generally *not* hold
for all `child` objects in `parent.children`. In other words,
the :attr:`parent` of a device in this property can be different
from this device!
.. note::
As the underlying library does not provide any means to directly
query the children of a device, this property performs a linear
search through all devices.
Return an iterable yielding a :class:`Device` object for each direct
child of this device.
.. udevversion:: 172
.. versionchanged:: 0.13
Requires udev version 172 now.
"""
for device in self.context.list_devices().match_parent(self):
if device != self:
yield device
@property
def ancestors(self):
"""
Yield all ancestors of this device from bottom to top.
Return an iterator yielding a :class:`Device` object for each
ancestor of this device from bottom to top.
.. versionadded:: 0.16
"""
parent = self.parent
while parent is not None:
yield parent
parent = parent.parent
def find_parent(self, subsystem, device_type=None):
"""
Find the parent device with the given ``subsystem`` and
``device_type``.
``subsystem`` is a byte or unicode string containing the name of the
subsystem, in which to search for the parent. ``device_type`` is a
byte or unicode string holding the expected device type of the parent.
It can be ``None`` (the default), which means, that no specific device
type is expected.
Return a parent :class:`Device` within the given ``subsystem`` and, if
``device_type`` is not ``None``, with the given ``device_type``, or
``None``, if this device has no parent device matching these
constraints.
.. versionadded:: 0.9
"""
subsystem = ensure_byte_string(subsystem)
if device_type is not None:
device_type = ensure_byte_string(device_type)
parent = self._libudev.udev_device_get_parent_with_subsystem_devtype(
self, subsystem, device_type)
if not parent:
return None
# parent device is not referenced, thus forcibly acquire a reference
return Device(self.context, self._libudev.udev_device_ref(parent))
def traverse(self):
"""
Traverse all parent devices of this device from bottom to top.
Return an iterable yielding all parent devices as :class:`Device`
objects, *not* including the current device. The last yielded
:class:`Device` is the top of the device hierarchy.
.. deprecated:: 0.16
Will be removed in 1.0. Use :attr:`ancestors` instead.
"""
import warnings
warnings.warn(
'Will be removed in 1.0. Use Device.ancestors instead.',
DeprecationWarning,
stacklevel=2
)
return self.ancestors
@property
def sys_path(self):
"""
Absolute path of this device in ``sysfs`` including the ``sysfs``
mount point as unicode string.
"""
return ensure_unicode_string(
self._libudev.udev_device_get_syspath(self))
@property
def device_path(self):
"""
Kernel device path as unicode string. This path uniquely identifies
a single device.
Unlike :attr:`sys_path`, this path does not contain the ``sysfs``
mount point. However, the path is absolute and starts with a slash
``'/'``.
"""
return ensure_unicode_string(
self._libudev.udev_device_get_devpath(self))
@property
def subsystem(self):
"""
Name of the subsystem this device is part of as unicode string.
:returns: name of subsystem if found, else None
:rtype: unicode string or NoneType
"""
subsys = self._libudev.udev_device_get_subsystem(self)
return None if subsys is None else ensure_unicode_string(subsys)
@property
def sys_name(self):
"""
Device file name inside ``sysfs`` as unicode string.
"""
return ensure_unicode_string(
self._libudev.udev_device_get_sysname(self))
@property
def sys_number(self):
"""
The trailing number of the :attr:`sys_name` as unicode string, or
``None``, if the device has no trailing number in its name.
.. note::
The number is returned as unicode string to preserve the exact
format of the number, especially any leading zeros:
>>> from pyudev import Context, Device
>>> context = Context()
>>> device = Devices.from_path(context, '/sys/devices/LNXSYSTM:00')
>>> device.sys_number
u'00'
To work with numbers, explicitly convert them to ints:
>>> int(device.sys_number)
0
.. versionadded:: 0.11
"""
number = self._libudev.udev_device_get_sysnum(self)
return ensure_unicode_string(number) if number is not None else None
@property
def device_type(self):
"""
Device type as unicode string, or ``None``, if the device type is
unknown.
>>> from pyudev import Context
>>> context = Context()
>>> for device in context.list_devices(subsystem='net'):
... '{0} - {1}'.format(device.sys_name, device.device_type or 'ethernet')
...
u'eth0 - ethernet'
u'wlan0 - wlan'
u'lo - ethernet'
u'vboxnet0 - ethernet'
.. versionadded:: 0.10
"""
device_type = self._libudev.udev_device_get_devtype(self)
if device_type is not None:
return ensure_unicode_string(device_type)
else:
return device_type
@property
def driver(self):
"""
The driver name as unicode string, or ``None``, if there is no
driver for this device.
.. versionadded:: 0.5
"""
driver = self._libudev.udev_device_get_driver(self)
return ensure_unicode_string(driver) if driver is not None else None
@property
def device_node(self):
"""
Absolute path to the device node of this device as unicode string or
``None``, if this device doesn't have a device node. The path
includes the device directory (see :attr:`Context.device_path`).
This path always points to the actual device node associated with
this device, and never to any symbolic links to this device node.
See :attr:`device_links` to get a list of symbolic links to this
device node.
.. warning::
For devices created with :meth:`from_device_file()`, the value of
this property is not necessary equal to the ``filename`` given to
:meth:`from_device_file()`.
"""
node = self._libudev.udev_device_get_devnode(self)
return ensure_unicode_string(node) if node is not None else None
@property
def device_number(self):
"""
The device number of the associated device as integer, or ``0``, if no
device number is associated.
Use :func:`os.major` and :func:`os.minor` to decompose the device
number into its major and minor number:
>>> import os
>>> from pyudev import Context, Device
>>> context = Context()
>>> sda = Devices.from_name(context, 'block', 'sda')
>>> sda.device_number
2048L
>>> (os.major(sda.device_number), os.minor(sda.device_number))
(8, 0)
For devices with an associated :attr:`device_node`, this is the same as
the ``st_rdev`` field of the stat result of the :attr:`device_node`:
>>> os.stat(sda.device_node).st_rdev
2048
.. versionadded:: 0.11
"""
return self._libudev.udev_device_get_devnum(self)
@property
def is_initialized(self):
"""
``True``, if the device is initialized, ``False`` otherwise.
A device is initialized, if udev has already handled this device and
has set up device node permissions and context, or renamed a network
device.
Consequently, this property is only implemented for devices with a
device node or for network devices. On all other devices this property
is always ``True``.
It is *not* recommended, that you use uninitialized devices.
.. seealso:: :attr:`time_since_initialized`
.. udevversion:: 165
.. versionadded:: 0.8
"""
return bool(self._libudev.udev_device_get_is_initialized(self))
@property
def time_since_initialized(self):
"""
The time elapsed since initialization as :class:`~datetime.timedelta`.
This property is only implemented on devices, which need to store
properties in the udev database. On all other devices this property is
simply zero :class:`~datetime.timedelta`.
.. seealso:: :attr:`is_initialized`
.. udevversion:: 165
.. versionadded:: 0.8
"""
microseconds = self._libudev.udev_device_get_usec_since_initialized(
self)
return timedelta(microseconds=microseconds)
@property
def device_links(self):
"""
An iterator, which yields the absolute paths (including the device
directory, see :attr:`Context.device_path`) of all symbolic links
pointing to the :attr:`device_node` of this device. The paths are
unicode strings.
UDev can create symlinks to the original device node (see
:attr:`device_node`) inside the device directory. This is often
used to assign a constant, fixed device node to devices like
removeable media, which technically do not have a constant device
node, or to map a single device into multiple device hierarchies.
The property provides access to all such symbolic links, which were
created by UDev for this device.
.. warning::
Links are not necessarily resolved by
:meth:`Devices.from_device_file()`. Hence do *not* rely on
``Devices.from_device_file(context, link).device_path ==
device.device_path`` from any ``link`` in ``device.device_links``.
"""
devlinks = self._libudev.udev_device_get_devlinks_list_entry(self)
for name, _ in udev_list_iterate(self._libudev, devlinks):
yield ensure_unicode_string(name)
@property
def action(self):
"""
The device event action as string, or ``None``, if this device was not
received from a :class:`Monitor`.
Usual actions are:
``'add'``
A device has been added (e.g. a USB device was plugged in)
``'remove'``
A device has been removed (e.g. a USB device was unplugged)
``'change'``
Something about the device changed (e.g. a device property)
``'online'``
The device is online now
``'offline'``
The device is offline now
.. warning::
Though the actions listed above are the most common, this property
*may* return other values, too, so be prepared to handle unknown
actions!
.. versionadded:: 0.16
"""
action = self._libudev.udev_device_get_action(self)
return ensure_unicode_string(action) if action is not None else None
@property
def sequence_number(self):
"""
The device event sequence number as integer, or ``0`` if this device
has no sequence number, i.e. was not received from a :class:`Monitor`.
.. versionadded:: 0.16
"""
return self._libudev.udev_device_get_seqnum(self)
@property
def attributes(self):
"""
The system attributes of this device as read-only
:class:`Attributes` mapping.
System attributes are basically normal files inside the the device
directory. These files contain all sorts of information about the
device, which may not be reflected by properties. These attributes
are commonly used for matching in udev rules, and can be printed
using ``udevadm info --attribute-walk``.
The values of these attributes are not always proper strings, and
can contain arbitrary bytes.
.. versionadded:: 0.5
"""
# do *not* cache the created object in an attribute of this class.
# Doing so creates an uncollectable reference cycle between Device and
# Attributes, because Attributes refers to this object through
# Attributes.device.
return Attributes(self)
@property
def properties(self):
"""
The udev properties of this object as read-only Properties mapping.
.. versionadded:: 0.21
"""
return Properties(self)
@property
def tags(self):
"""
A :class:`Tags` object representing the tags attached to this device.
The :class:`Tags` object supports a test for a single tag as well as
iteration over all tags:
>>> from pyudev import Context
>>> context = Context()
>>> device = next(iter(context.list_devices(tag='systemd')))
>>> 'systemd' in device.tags
True
>>> list(device.tags)
[u'seat', u'systemd', u'uaccess']
Tags are arbitrary classifiers that can be attached to devices by udev
scripts and daemons. For instance, systemd_ uses tags for multi-seat_
support.
.. _systemd: http://freedesktop.org/wiki/Software/systemd
.. _multi-seat: http://www.freedesktop.org/wiki/Software/systemd/multiseat
.. udevversion:: 154
.. versionadded:: 0.6
.. versionchanged:: 0.13
Return a :class:`Tags` object now.
"""
return Tags(self)
def __iter__(self):
"""
Iterate over the names of all properties defined for this device.
Return a generator yielding the names of all properties of this
device as unicode strings.
.. deprecated:: 0.21
Will be removed in 1.0. Access properties with Device.properties.
"""
import warnings
warnings.warn(
'Will be removed in 1.0. Access properties with Device.properties.',
DeprecationWarning,
stacklevel=2
)
return self.properties.__iter__()
def __len__(self):
"""
Return the amount of properties defined for this device as integer.
.. deprecated:: 0.21
Will be removed in 1.0. Access properties with Device.properties.
"""
import warnings
warnings.warn(
'Will be removed in 1.0. Access properties with Device.properties.',
DeprecationWarning,
stacklevel=2
)
return self.properties.__len__()
def __getitem__(self, prop):
"""
Get the given property from this device.
``prop`` is a unicode or byte string containing the name of the
property.
Return the property value as unicode string, or raise a
:exc:`~exceptions.KeyError`, if the given property is not defined
for this device.
.. deprecated:: 0.21
Will be removed in 1.0. Access properties with Device.properties.
"""
import warnings
warnings.warn(
'Will be removed in 1.0. Access properties with Device.properties.',
DeprecationWarning,
stacklevel=2
)
return self.properties.__getitem__(prop)
def asint(self, prop):
"""
Get the given property from this device as integer.
``prop`` is a unicode or byte string containing the name of the
property.
Return the property value as integer. Raise a
:exc:`~exceptions.KeyError`, if the given property is not defined
for this device, or a :exc:`~exceptions.ValueError`, if the property
value cannot be converted to an integer.
.. deprecated:: 0.21
Will be removed in 1.0. Use Device.properties.asint() instead.
"""
import warnings
warnings.warn(
'Will be removed in 1.0. Use Device.properties.asint instead.',
DeprecationWarning,
stacklevel=2
)
return self.properties.asint(prop)
def asbool(self, prop):
"""
Get the given property from this device as boolean.
A boolean property has either a value of ``'1'`` or of ``'0'``,
where ``'1'`` stands for ``True``, and ``'0'`` for ``False``. Any
other value causes a :exc:`~exceptions.ValueError` to be raised.
``prop`` is a unicode or byte string containing the name of the
property.
Return ``True``, if the property value is ``'1'`` and ``False``, if
the property value is ``'0'``. Any other value raises a
:exc:`~exceptions.ValueError`. Raise a :exc:`~exceptions.KeyError`,
if the given property is not defined for this device.
.. deprecated:: 0.21
Will be removed in 1.0. Use Device.properties.asbool() instead.
"""
import warnings
warnings.warn(
'Will be removed in 1.0. Use Device.properties.asbool instead.',
DeprecationWarning,
stacklevel=2
)
return self.properties.asbool(prop)
def __hash__(self):
return hash(self.device_path)
def __eq__(self, other):
if isinstance(other, Device):
return self.device_path == other.device_path
else:
return self.device_path == other
def __ne__(self, other):
if isinstance(other, Device):
return self.device_path != other.device_path
else:
return self.device_path != other
def __gt__(self, other):
raise TypeError('Device not orderable')
def __lt__(self, other):
raise TypeError('Device not orderable')
def __le__(self, other):
raise TypeError('Device not orderable')
def __ge__(self, other):
raise TypeError('Device not orderable')
class Properties(Mapping):
"""
udev properties :class:`Device` objects.
.. versionadded:: 0.21
"""
def __init__(self, device):
self.device = device
self._libudev = device._libudev
def __iter__(self):
"""
Iterate over the names of all properties defined for the device.
Return a generator yielding the names of all properties of this
device as unicode strings.
"""
properties = \
self._libudev.udev_device_get_properties_list_entry(self.device)
for name, _ in udev_list_iterate(self._libudev, properties):
yield ensure_unicode_string(name)
def __len__(self):
"""
Return the amount of properties defined for this device as integer.
"""
properties = \
self._libudev.udev_device_get_properties_list_entry(self.device)
return sum(1 for _ in udev_list_iterate(self._libudev, properties))
def __getitem__(self, prop):
"""
Get the given property from this device.
``prop`` is a unicode or byte string containing the name of the
property.
Return the property value as unicode string, or raise a
:exc:`~exceptions.KeyError`, if the given property is not defined
for this device.
"""
value = self._libudev.udev_device_get_property_value(
self.device,
ensure_byte_string(prop)
)
if value is None:
raise KeyError(prop)
return ensure_unicode_string(value)
def asint(self, prop):
"""
Get the given property from this device as integer.
``prop`` is a unicode or byte string containing the name of the
property.
Return the property value as integer. Raise a
:exc:`~exceptions.KeyError`, if the given property is not defined
for this device, or a :exc:`~exceptions.ValueError`, if the property
value cannot be converted to an integer.
"""
return int(self[prop])
def asbool(self, prop):
"""
Get the given property from this device as boolean.
A boolean property has either a value of ``'1'`` or of ``'0'``,
where ``'1'`` stands for ``True``, and ``'0'`` for ``False``. Any
other value causes a :exc:`~exceptions.ValueError` to be raised.
``prop`` is a unicode or byte string containing the name of the
property.
Return ``True``, if the property value is ``'1'`` and ``False``, if
the property value is ``'0'``. Any other value raises a
:exc:`~exceptions.ValueError`. Raise a :exc:`~exceptions.KeyError`,
if the given property is not defined for this device.
"""
return string_to_bool(self[prop])
class Attributes(object):
"""
udev attributes for :class:`Device` objects.
.. versionadded:: 0.5
"""
def __init__(self, device):
self.device = device
self._libudev = device._libudev
@property
def available_attributes(self):
"""
Yield the ``available`` attributes for the device.
It is not guaranteed that a key in this list will have a value.
It is not guaranteed that a key not in this list will not have a value.
It is guaranteed that the keys in this list are the keys that libudev
considers to be "available" attributes.
If libudev version does not define udev_device_get_sysattr_list_entry()
yields nothing.
See rhbz#1267584.
"""
if not hasattr(self._libudev, 'udev_device_get_sysattr_list_entry'):
return # pragma: no cover
attrs = self._libudev.udev_device_get_sysattr_list_entry(self.device)
for attribute, _ in udev_list_iterate(self._libudev, attrs):
yield ensure_unicode_string(attribute)
def _get(self, attribute):
"""
Get the given system ``attribute`` for the device.
:param attribute: the key for an attribute value
:type attribute: unicode or byte string
:returns: the value corresponding to ``attribute``
:rtype: an arbitrary sequence of bytes
:raises KeyError: if no value found
"""
value = self._libudev.udev_device_get_sysattr_value(
self.device,
ensure_byte_string(attribute)
)
if value is None:
raise KeyError(attribute)
return value
def get(self, attribute, default=None):
"""
Get the given system ``attribute`` for the device.
:param attribute: the key for an attribute value
:type attribute: unicode or byte string
:param default: a default if no corresponding value found
:type default: a sequence of bytes
:returns: the value corresponding to ``attribute`` or ``default``
:rtype: object
"""
try:
return self._get(attribute)
except KeyError:
return default
def asstring(self, attribute):
"""
Get the given ``attribute`` for the device as unicode string.
:param attribute: the key for an attribute value
:type attribute: unicode or byte string
:returns: the value corresponding to ``attribute``, as unicode
:rtype: unicode
:raises KeyError: if no value found for ``attribute``
:raises UnicodeDecodeError: if value is not convertible
"""
return ensure_unicode_string(self._get(attribute))
def asint(self, attribute):
"""
Get the given ``attribute`` as an int.
:param attribute: the key for an attribute value
:type attribute: unicode or byte string
:returns: the value corresponding to ``attribute``, as an int
:rtype: int
:raises KeyError: if no value found for ``attribute``
:raises UnicodeDecodeError: if value is not convertible to unicode
:raises ValueError: if unicode value can not be converted to an int
"""
return int(self.asstring(attribute))
def asbool(self, attribute):
"""
Get the given ``attribute`` from this device as a bool.
:param attribute: the key for an attribute value
:type attribute: unicode or byte string
:returns: the value corresponding to ``attribute``, as bool
:rtype: bool
:raises KeyError: if no value found for ``attribute``
:raises UnicodeDecodeError: if value is not convertible to unicode
:raises ValueError: if unicode value can not be converted to a bool
A boolean attribute has either a value of ``'1'`` or of ``'0'``,
where ``'1'`` stands for ``True``, and ``'0'`` for ``False``. Any
other value causes a :exc:`~exceptions.ValueError` to be raised.
"""
return string_to_bool(self.asstring(attribute))
class Tags(Iterable, Container):
"""
A iterable over :class:`Device` tags.
Subclasses the ``Container`` and the ``Iterable`` ABC.
"""
# pylint: disable=too-few-public-methods
def __init__(self, device):
self.device = device
self._libudev = device._libudev
def _has_tag(self, tag):
"""
Whether ``tag`` exists.
:param tag: unicode string with name of tag
:rtype: bool
"""
if hasattr(self._libudev, 'udev_device_has_tag'):
return bool(self._libudev.udev_device_has_tag(
self.device, ensure_byte_string(tag)))
else: # pragma: no cover
return any(t == tag for t in self)
def __contains__(self, tag):
"""
Check for existence of ``tag``.
``tag`` is a tag as unicode string.
Return ``True``, if ``tag`` is attached to the device, ``False``
otherwise.
"""
return self._has_tag(tag)
def __iter__(self):
"""
Iterate over all tags.
Yield each tag as unicode string.
"""
tags = self._libudev.udev_device_get_tags_list_entry(self.device)
for tag, _ in udev_list_iterate(self._libudev, tags):
yield ensure_unicode_string(tag)