3
�L�j�] � @ s
d Z ddlZdZddddg\ZZZZeZe Z
G dd � d e �Z d
d � Z
d d
� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd ZZy�ddlZddlZddlZd gZej j d �s�ej d � xLeD ]DZ yej ej!j"e ��Z#W n e$k
r� w�Y nX e%e#d �r�e#j&ZP q�W [ej d k�r@eej'� j(j)d!�d �d"k�r@dZy ej*j+Z#W n dZ#Y nX e,e#d#e,e#d$d��ZW n Y nX d%d&� Z-d'd(� Z.d)d*� Z/da0e.eegZ1e-eeeeegZ2d+d,� Z3da4d9d-d.�Z5d/d0� Z6d1d2� Z7d3d4� Z8e d5�Z9e d6�Z:e d7�Z;e d8�Z>> import uuid
# make a UUID based on the host ID and current time
>>> uuid.uuid1() # doctest: +SKIP
UUID('a8098c1a-f86e-11da-bd1a-00112444be1e')
# make a UUID using an MD5 hash of a namespace UUID and a name
>>> uuid.uuid3(uuid.NAMESPACE_DNS, 'python.org')
UUID('6fa459ea-ee8a-3ca4-894e-db77e160355e')
# make a random UUID
>>> uuid.uuid4() # doctest: +SKIP
UUID('16fd2706-8baf-433b-82eb-8c7fada847da')
# make a UUID using a SHA-1 hash of a namespace UUID and a name
>>> uuid.uuid5(uuid.NAMESPACE_DNS, 'python.org')
UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')
# make a UUID from a string of hex digits (braces and hyphens ignored)
>>> x = uuid.UUID('{00010203-0405-0607-0809-0a0b0c0d0e0f}')
# convert a UUID to a string of hex digits in standard form
>>> str(x)
'00010203-0405-0607-0809-0a0b0c0d0e0f'
# get the raw 16 bytes of the UUID
>>> x.bytes
b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f'
# make a UUID from a 16-byte string
>>> uuid.UUID(bytes=x.bytes)
UUID('00010203-0405-0607-0809-0a0b0c0d0e0f')
� NzKa-Ping Yee z reserved for NCS compatibilityzspecified in RFC 4122z$reserved for Microsoft compatibilityz reserved for future definitionc @ s e Zd ZdZd7dd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zedd� �Zedd � �Zed d � �Zed d � �Zed!d"� �Zed#d$� �Zed%d&� �Zed'd(� �Zed)d*� �Zed+d,� �Zed-d.� �Zed/d0� �Zed1d2� �Z ed3d4� �Z ed5d6� �Z dS )8�UUIDa� Instances of the UUID class represent UUIDs as specified in RFC 4122.
UUID objects are immutable, hashable, and usable as dictionary keys.
Converting a UUID to a string with str() yields something in the form
'12345678-1234-1234-1234-123456789abc'. The UUID constructor accepts
five possible forms: a similar string of hexadecimal digits, or a tuple
of six integer fields (with 32-bit, 16-bit, 16-bit, 8-bit, 8-bit, and
48-bit values respectively) as an argument named 'fields', or a string
of 16 bytes (with all the integer fields in big-endian order) as an
argument named 'bytes', or a string of 16 bytes (with the first three
fields in little-endian order) as an argument named 'bytes_le', or a
single 128-bit integer as an argument named 'int'.
UUIDs have these read-only attributes:
bytes the UUID as a 16-byte string (containing the six
integer fields in big-endian byte order)
bytes_le the UUID as a 16-byte string (with time_low, time_mid,
and time_hi_version in little-endian byte order)
fields a tuple of the six integer fields of the UUID,
which are also available as six individual attributes
and two derived attributes:
time_low the first 32 bits of the UUID
time_mid the next 16 bits of the UUID
time_hi_version the next 16 bits of the UUID
clock_seq_hi_variant the next 8 bits of the UUID
clock_seq_low the next 8 bits of the UUID
node the last 48 bits of the UUID
time the 60-bit timestamp
clock_seq the 14-bit sequence number
hex the UUID as a 32-character hexadecimal string
int the UUID as a 128-bit integer
urn the UUID as a URN as specified in RFC 4122
variant the UUID variant (one of the constants RESERVED_NCS,
RFC_4122, RESERVED_MICROSOFT, or RESERVED_FUTURE)
version the UUID version number (1 through 5, meaningful only
when the variant is RFC_4122)
Nc C s� |||||gj d�dkr td��|dk rl|jdd�jdd�}|jd�jdd�}t|�d krbtd
��t|d �}|dk r�t|�d kr�td ��|d(dd)� |d*d+d,� |d-d.d/� |dd� }|dk � r�t|�d kr�td��tj|dd�}|dk �r"t|�dk�r
td��|\}}} }
} } d| k�o.d0k n �s>td��d| k�oRd1k n �sbtd��d| k�ovd2k n �s�td��d|
k�o�d3k n �s�td��d| k�o�d4k n �s�td��d| k�o�d5k n �s�td��|
d> | B }
|d > |d > B | d > B |
d> B | B }|dk �rTd| k�oDd
d > k n �sTtd ��|dk �r�d
| k�ord!kn �s�td"��|d7M }|d8O }|d:M }||d&> O }|| jd'< dS );am Create a UUID from either a string of 32 hexadecimal digits,
a string of 16 bytes as the 'bytes' argument, a string of 16 bytes
in little-endian order as the 'bytes_le' argument, a tuple of six
integers (32-bit time_low, 16-bit time_mid, 16-bit time_hi_version,
8-bit clock_seq_hi_variant, 8-bit clock_seq_low, 48-bit node) as
the 'fields' argument, or a single 128-bit integer as the 'int'
argument. When a string of hex digits is given, curly braces,
hyphens, and a URN prefix are all optional. For example, these
expressions all yield the same UUID:
UUID('{12345678-1234-5678-1234-567812345678}')
UUID('12345678123456781234567812345678')
UUID('urn:uuid:12345678-1234-5678-1234-567812345678')
UUID(bytes='\x12\x34\x56\x78'*4)
UUID(bytes_le='\x78\x56\x34\x12\x34\x12\x78\x56' +
'\x12\x34\x56\x78\x12\x34\x56\x78')
UUID(fields=(0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678))
UUID(int=0x12345678123456781234567812345678)
Exactly one of 'hex', 'bytes', 'bytes_le', 'fields', or 'int' must
be given. The 'version' argument is optional; if given, the resulting
UUID will have its variant and version set according to RFC 4122,
overriding the given 'hex', 'bytes', 'bytes_le', 'fields', or 'int'.
N� zGone of the hex, bytes, bytes_le, fields, or int arguments must be givenzurn:� zuuid:z{}�-� z$badly formed hexadecimal UUID string� z bytes_le is not a 16-char string� � � z bytes is not a 16-char string�big)� byteorderzfields is not a 6-tupler z*field 1 out of range (need a 32-bit value)z*field 2 out of range (need a 16-bit value)z*field 3 out of range (need a 16-bit value)z*field 4 out of range (need an 8-bit value)z*field 5 out of range (need an 8-bit value)�0 z*field 6 out of range (need a 48-bit value)�` �P �@ � z*int is out of range (need a 128-bit value)� zillegal version numberi � i � i � �L �int� �����r r r � r r l i i � r l l l���� l l l���� ) �count� TypeError�replace�strip�len�
ValueError�int_�
from_bytes�__dict__)�self�hex�bytes�bytes_le�fieldsr �version�time_low�time_mid�time_hi_version�clock_seq_hi_variant�
clock_seq_low�node� clock_seq� r/ � /usr/lib64/python3.6/uuid.py�__init__j sZ
6
$
z
UUID.__init__c C s t |t�r| j|jkS tS )N)�
isinstancer r �NotImplemented)r" �otherr/ r/ r0 �__eq__� s
z UUID.__eq__c C s t |t�r| j|jk S tS )N)r2 r r r3 )r" r4 r/ r/ r0 �__lt__� s
z UUID.__lt__c C s t |t�r| j|jkS tS )N)r2 r r r3 )r" r4 r/ r/ r0 �__gt__� s
z UUID.__gt__c C s t |t�r| j|jkS tS )N)r2 r r r3 )r" r4 r/ r/ r0 �__le__� s
z UUID.__le__c C s t |t�r| j|jkS tS )N)r2 r r r3 )r" r4 r/ r/ r0 �__ge__� s
z UUID.__ge__c C s
t | j�S )N)�hashr )r" r/ r/ r0 �__hash__� s z
UUID.__hash__c C s | j S )N)r )r" r/ r/ r0 �__int__� s z UUID.__int__c C s d| j jt| �f S )Nz%s(%r))� __class__�__name__�str)r" r/ r/ r0 �__repr__� s z
UUID.__repr__c C s t d��d S )NzUUID objects are immutable)r )r" �name�valuer/ r/ r0 � __setattr__� s zUUID.__setattr__c C sD d| j }d|d d� |dd� |dd� |dd� |dd � f S )Nz%032xz%s-%s-%s-%s-%sr
� r � )r )r" r# r/ r/ r0 �__str__� s
z UUID.__str__c C s | j jdd�S )Nr r )r �to_bytes)r" r/ r/ r0 r$ � s z
UUID.bytesc C s< | j }|dd d� |ddd � |d
d d � |dd � S )
Nr r r r
r r r r r r r r )r$ )r" r$ r/ r/ r0 r% � s (z
UUID.bytes_lec C s | j | j| j| j| j| jfS )N)r( r) r* r+ r, r- )r" r/ r/ r0 r& � s z UUID.fieldsc C s
| j d? S )Nr )r )r" r/ r/ r0 r( � s z
UUID.time_lowc C s | j d? d@ S )Nr i�� )r )r" r/ r/ r0 r) � s z
UUID.time_midc C s | j d? d@ S )Nr i�� )r )r" r/ r/ r0 r* � s zUUID.time_hi_versionc C s | j d? d@ S )N�8 �� )r )r" r/ r/ r0 r+ s zUUID.clock_seq_hi_variantc C s | j d? d@ S )Nr
rI )r )r" r/ r/ r0 r, s zUUID.clock_seq_lowc C s | j d@ d> | jd> B | jB S )Ni� r
r )r* r) r( )r" r/ r/ r0 �time
s z UUID.timec C s | j d@ d> | jB S )N�? r
)r+ r, )r" r/ r/ r0 r. s zUUID.clock_seqc C s
| j d@ S )Nl ��� )r )r" r/ r/ r0 r- s z UUID.nodec C s
d| j S )Nz%032x)r )r" r/ r/ r0 r# s zUUID.hexc C s dt | � S )Nz urn:uuid:)r? )r" r/ r/ r0 �urn s zUUID.urnc C s2 | j d@ stS | j d@ s tS | j d@ s*tS tS d S )Ni � r
i @ i l l l )r � RESERVED_NCS�RFC_4122�RESERVED_MICROSOFT�RESERVED_FUTURE)r" r/ r/ r0 �variant s
z UUID.variantc C s | j tkr t| jd? d@ �S d S )Nr � )rQ rN r )r" r/ r/ r0 r' + s
z UUID.version)NNNNNN) r> �
__module__� __qualname__�__doc__r1 r5 r6 r7 r8 r9 r; r< r@ rC rF �propertyr$ r% r& r( r) r* r+ r, rJ r. r- r# rL rQ r' r/ r/ r/ r0 r : s8 .
O r c G s� dd l }dd l}dd l}|j| �}|d krP|jjd�}|j| |d�}|d krPd S t|j�}d|d< |j|f| |j |j
|d�}|S ) Nr �/sbin� /usr/sbin)�path�C�LC_ALL)�stdout�stderr�env)rW rX ) �os�shutil�
subprocessZwhich�pathsep�join�dict�environ�Popen�PIPEZDEVNULL) �command�argsr_ r` ra �
executablerY r^ �procr/ r/ r0 �_popen1 s
rl c
C s� y�t | f|j� �� }|s d S |�� x�|jD ]z}|j� j� j� }xdtt|��D ]T}|| |krLy*|||� }t|jdd�d�} | r�| S W qL t t
fk
r� Y qLX qLW q*W W d Q R X W n t k
r� Y nX d S )N� :� r ) rl �splitr\ �lower�rstrip�ranger r r r �
IndexError�OSError)
rh ri Zhw_identifiersZ get_indexrk �line�words�i�word�macr/ r/ r0 � _find_macD s$ rz c C s0 d } x&d
D ] }t d|| d d
� �}|r
|S q
W d S )z5Get the hardware address on Unix by running ifconfig.� hwaddr� ether� address:� lladdrr �-a�-avZifconfigc S s | d S )Nr r/ )rw r/ r/ r0 �b s z#_ifconfig_getnode..N)r{ r| r} r~ )r r r� )rz )�keywordsri ry r/ r/ r0 �_ifconfig_getnode] s
r� c C s t dddgdd� �} | r | S dS )z/Get the hardware address on Unix by running ip.Zip�links
link/etherc S s | d S )Nr r/ )rw r/ r/ r0 r� i s z _ip_getnode..N)rz )ry r/ r/ r0 � _ip_getnodef s r� c C s� ddl } ddl}y|j|j� �}W n tk
r6 dS X tdd| j|�gdd� �}|rZ|S tdd| j|�gdd� �}|r||S tdd| jd| �gd d� �}|r�|S dS )
z0Get the hardware address on Unix by running arp.r NZarpz-anc S s dS )Nr r r/ )rw r/ r/ r0 r� v s z _arp_getnode..c S s | d S )Nr r/ )rw r/ r/ r0 r� { s z(%s)c S s | d S )N� r/ )rw r/ r/ r0 r� � s )r_ �socketZ
gethostbynameZ gethostnamert rz �fsencode)r_ r� Zip_addrry r/ r/ r0 � _arp_getnodem s
r� c C s t dddgdd� �S )z4Get the hardware address on Unix by running lanscan.Zlanscanz-ais lan0c S s dS )Nr r/ )rw r/ r/ r0 r� � s z"_lanscan_getnode..)rz r/ r/ r/ r0 �_lanscan_getnode� s r� c " C s� y�t dd�} | sdS | �� | jj� j� j� }y|jd�}W n tk
rN dS X xt| jD ]j}yL|j� j� }|| }t|�dkr�|jd�dkr�t |j
dd�d �}|r�|S W qX tt fk
r� Y qXX qXW W dQ R X W n t k
r� Y nX dS )
z4Get the hardware address on Unix by running netstat.Znetstatz-iaNs Address� rm r rn r )
rl r\ �readlinerq ro �indexr r r r r rs rt )rk rv rw ru rx ry r/ r/ r0 �_netstat_getnode� s,
r� c
C s ddl } ddl}ddl}dddg}y:ddl}|jd�}|jjj|d� |jd|j j
d�� W n Y nX x�|D ]�}y$|j | j j
|d�d g|jd
d �}W n tk
r� wpY nX |�J xB|jD ]8}|jd �d j� j� } |jd| �r�t| jdd�d�S q�W W dQ R X qpW dS )z| | kodkn r>tjd�}t |� tt|j�d�S ddl}t|j� d �}t|d �d }tdk r~|tkr~td }|a|dkr�ddl }|j
d �}|d
@ }|d ? d @ }|d
? d@ } |d@ }
|d? d@ } | dkr�t � } t||| | |
| fdd�S )a Generate a UUID from a host ID, sequence number, and the current time.
If 'node' is not given, getnode() is used to obtain the hardware
address. If 'clock_seq' is given, it is used as the sequence number;
otherwise a random 14-bit sequence number is chosen.Nr )r$ r g e��A�d l @'Hw�
r � l �� r i�� r
i� rI r
rK )r& r' ) r� r� r� r r� r� rJ r �_last_timestampr� r� r� ) r- r. r� rJ Z nanosecondsZ timestampr� r( r) r* r, r+ r/ r/ r0 �uuid1D s,
r� c C s< ddl m} || jt|d� dd�j� }t|dd� dd �S )
zAGenerate a UUID from the MD5 hash of a namespace UUID and a name.r )�md5zutf-8F)ZusedforsecurityNr r )r$ r' )�hashlibr� r$ �digestr )� namespacerA r� r� r/ r/ r0 �uuid3g s
r� c C s t tjd�dd�S )zGenerate a random UUID.r r )r$ r' )r r_ �urandomr/ r/ r/ r0 �uuid4p s r� c C s8 ddl m} || jt|d� �j� }t|dd� dd�S )zCGenerate a UUID from the SHA-1 hash of a namespace UUID and a name.r )�sha1zutf-8Nr r )r$ r' )r� r� r$ r� r )r� rA r� r: r/ r/ r0 �uuid5t s r� z$6ba7b810-9dad-11d1-80b4-00c04fd430c8z$6ba7b811-9dad-11d1-80b4-00c04fd430c8z$6ba7b812-9dad-11d1-80b4-00c04fd430c8z$6ba7b814-9dad-11d1-80b4-00c04fd430c8)NN)=rU r_ �
__author__rM rN rO rP r r r$ r� �objectr rl rz r� r� r� r� r� r� r� r� r� r� Z ctypes.utilr� Z _libnamesr� �
startswith�appendZlibnameZCDLL�utilZ find_library�lib� Exception�hasattrr� �uname�releasero r� Zrpcrt4�getattrr� r� r� r� r� r� r� r� r� r� r� r� Z
NAMESPACE_DNSZ
NAMESPACE_URLZ
NAMESPACE_OIDZNAMESPACE_X500r/ r/ r/ r0 �- sz x "
#