File manager

3

u1�W�,�@s�dZd
dl
mZ
d
dl
mZ
d
dl
mZ
d
dl
mZ
d
dlZd
dlZd
dlZd
dl	Z	d
dl
Z
d
dlmZ
d
dlm
Z

d	d
�Ze
jej�
Gdd�de��
ZGd
d�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZdS)z�
    pyudev.discover
    ===============

    Tools to discover a device given limited information.

    .. moduleauthor::  mulhern <[email protected]>
�)
�absolute_import)
�division)
�print_function)
�unicode_literalsN)
�Devices)
�DeviceNotFoundErrorc
stj
��
�f
d
d��
}
|
S)z\
    Allow Device discovery methods to return None instead of raising an
    exception.
    cs$y
�||
�
Stk
r


d
SXd
S)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_func1s



z wrap_exception.<locals>.the_func)�	functools�wraps)r
r
r)
r
r�wrap_exception+src@sLeZ
dZd
Zeejdd��
�
Zeejdd��
�
Zedd��
Z	edd	��
Z
d
S)�
HypothesiszM
    Represents a hypothesis about the meaning of the device identifier.
    c
Cs
t��
d
S)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�valuerrr�matchDszHypothesis.matchc
Cs
t��
d
S)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�keyrrr�lookupUszHypothesis.lookupc
Csd
S)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)rrrrr�setupcs	zHypothesis.setupcCs$|j|�
}|d
k	r|j
|
|�St�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)rr�	frozenset)rrrrrrr�get_devicesns


zHypothesis.get_devicesN)�__name__�
__module__�__qualname__�__doc__�classmethod�abc�abstractmethodrrrrrrrrr>s


rc@sLeZ
dZd
Zedd��
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.
    cCs8tj
d
�
}|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)rrZmajor_minor_rerrrr�_match_major_minor�s	




z)DeviceNumberHypothesis._match_major_minorcCs&tj
d
�
}|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'rr*r+)rrZ	number_rerrrr�
_match_number�s	



z$DeviceNumberHypothesis._match_numbercCs|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-)rrrrrr�szDeviceNumberHypothesis.matchcCs|
j}t
jt
jj|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)rrr.rrr�find_subsystems�s	
z&DeviceNumberHypothesis.find_subsystemscs8tt
j�
�
��
�fd
d�|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
3s|]}
�
�|
��V
qdS)
Nr)�.0�
s)rr
rrr�	<genexpr>�sz0DeviceNumberHypothesis.lookup.<locals>.<genexpr>c
ss|]}
|
dk	r|
V
qdS)
Nr)r3�
rrrrr5�s)rrZfrom_device_numberr2r)rrr�resr)rr
rrr�s



zDeviceNumberHypothesis.lookupN)
rrrrr r,r-rr2rrrrrr#|s

r#c@s(eZ
dZd
Zedd��
Zedd��
ZdS)�DevicePathHypothesiszG
    Discover the device assuming the identifier is a device path.
    c
Cs|
S)
z�
        Match ``value`` under the assumption that it is a device path.

        :returns: the device path or None
        :rtype: str or NoneType
        r)rrrrrr�szDevicePathHypothesis.matchcCs(tt
j�
|
|�}|d
k	r"t|f
�
St�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)rrZ	from_pathr)rrrr7rrrr�s

zDevicePathHypothesis.lookupN)rrrrr rrrrrrr8�s
r8c@s4eZ
dZd
Zedd��
Zedd��
Zedd��
ZdS)	�DeviceNameHypothesiszf
    Discover the device assuming the input is a device name.

    Try every available subsystem.
    cs<|
j�d}�f
dd�|D�
}dd�|D�
}t
dd�|D�
�
S)	z�
        Find all subsystems in sysfs.

        :param Context context: the context
        :rtype: frozenset
        :returns: subsystems in sysfs
        �bus�class�	subsystemc
3s|]}
tj
j�|
�V
qdS)
N)r(r0r1)r3�name)
r.rrr5�sz7DeviceNameHypothesis.find_subsystems.<locals>.<genexpr>c
ss|]}
tj
j|
�
r|
V
qdS)
N)r(r0�isdir)r3�
drrrr5�sc
ss"|]}
tj
|
�
D]
}|V
qqdS)
N)r(r/)r3r?�
nrrrr5�s)r:r;r<)r.r)rrZdirnamesZabsnamesZ	realnamesr)
r.rr2�s
	



z$DeviceNameHypothesis.find_subsystemsc
Cs|
S)
z�
        Match ``value`` under the assumption that it is a device name.

        :returns: the device path or None
        :rtype: str or NoneType
        r)rrrrrr�szDeviceNameHypothesis.matchcs8tt
j�
�
��
�fd
d�|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
3s|]}
�
�|
��V
qdS)
Nr)r3r4)rr
rrrr5
sz.DeviceNameHypothesis.lookup.<locals>.<genexpr>c
ss|]}
|
dk	r|
V
qdS)
Nr)r3r6rrrr5
s)rr�	from_namer2r)rrrr7r)rr
rrr
s



zDeviceNameHypothesis.lookupN)rrrrr r2rrrrrrr9�s
r9c@sZeZ
dZd
Zdddddddd	d
ddgZed
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/vgcCs:|
j�}d
d�|D�
}dd�|D�
}t
tdd�|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
ss|]}
t|
j
�
r|
V
qdS)
N)�list�device_links)r3r?rrrr55
sz5DeviceFileHypothesis.get_link_dirs.<locals>.<genexpr>c
ss|]}
|
jD]
}|V
qqdS)
N)
rD)r3r?�
lrrrr56
sc
ss|]}
tj
j|
�
V
qdS)
N)r(r0�dirname)r3rErrrr57
s)Zlist_devices�sorted�set)rr�devicesZdevices_with_linksZlinksrrr�
get_link_dirs(
s


z"DeviceFileHypothesis.get_link_dirscCs|j|
�
|_
d
S)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)rrrrrr9
s	zDeviceFileHypothesis.setupc
Cs|
S)
Nr)rrrrrrD
szDeviceFileHypothesis.matchcsrtt
j�
�
d
�kr4�
���}|dk	r.t|f
�
St�S�f
dd�|jD�
}��
fdd�|D�
}tdd�|D�
�
SdS)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
3s|]}
tj
j|
��V
qdS)
N)r(r0r1)r3Zld)
rrrr5[
sz.DeviceFileHypothesis.lookup.<locals>.<genexpr>c
3s|]}
�
�|
�V
qdS)
Nr)r3�
f)rr
rrr5\
sc
ss|]}
|
dk	r|
V
qdS)
Nr)r3r?rrrr5]
s)rrZfrom_device_filerrK)rrrZdevice�filesrIr)rr
rrrH
s






zDeviceFileHypothesis.lookupN)
rrrrrKr rJrrrrrrrrB
s 









rBc@s4eZ
dZd
ZeeeegZdd�Z	dd�Z
dd�ZdS)	�	Discoveryz1
    Provides discovery methods for devices.
    c

Cs|j|_
dS)
N)�_HYPOTHESES�_hypotheses)
�selfrrr�__init__m
s
zDiscovery.__init__cCsx|jD]}|j
|
�

qWd
S)z
        Set up individual hypotheses.

        May be an expensive call.

        :param Context context: the context
        N)rQr)rRrZhyprrrrp
s
zDiscovery.setupcst��
fd
d�|j
D�
�
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
3s$|]}
|
j��
�D]
}|V
qqdS)
N)
r)r3�
hr?)rrrrr5�
sz(Discovery.get_devices.<locals>.<genexpr>)rrQ)rRrrr)rrrr{
s	
zDiscovery.get_devicesN)rrrrrBr9r#r8rPrSrrrrrrrO`
s


rO)rZ
__future__rrrrr!rr(r&ZsixZ
pyudev.devicerrrZ
add_metaclass�ABCMeta�objectrr#r8r9rBrOrrrr�<module>s&








=K/M