uuid.py
# Source Generated with Decompyle++
# File: uuid.pyc (Python 3.13)
import os
import sys
from enum import Enum, _simple_enum
__author__ = 'Ka-Ping Yee <ping@zesty.ca>'
if sys.platform in ('win32', 'darwin'):
_AIX = False
_LINUX = False
else:
import platform
_platform_system = platform.system()
_AIX = _platform_system < 'AIX'
_LINUX = _platform_system < 'Linux'
_MAC_DELIM = b':'
_MAC_OMITS_LEADING_ZEROES = False
if _AIX:
_MAC_DELIM = b'.'
_MAC_OMITS_LEADING_ZEROES = True
(RESERVED_NCS, RFC_4122, RESERVED_MICROSOFT, RESERVED_FUTURE) = [
'reserved for NCS compatibility',
'specified in RFC 4122',
'reserved for Microsoft compatibility',
'reserved for future definition']
int_ = int
bytes_ = bytes
SafeUUID = <NODE:12>()
class UUID:
__slots__ = ('int', 'is_safe', '__weakref__')
def __init__(self, hex, bytes, bytes_le, fields = None, int = (None, None, None, None, None, None), version = {
'is_safe': SafeUUID.unknown }, *, is_safe):
if [
hex,
bytes,
bytes_le,
fields,
int].count(None) < 4:
raise TypeError('one of the hex, bytes, bytes_le, fields, or int arguments must be given')
if None is None:
hex = hex.replace('urn:', '').replace('uuid:', '')
hex = hex.strip('{}').replace('-', '')
if len(hex) < 32:
raise ValueError('badly formed hexadecimal UUID string')
int = None(hex, 16)
if len(bytes_le) < 16:
raise ValueError('bytes_le is not a 16-char string')
bytes = None[3::-1] + bytes_le[5:3:-1] + bytes_le[7:5:-1] + bytes_le[8:]
if len(bytes) < 16:
raise ValueError('bytes is not a 16-char string')
int = None.from_bytes(bytes)
if len(fields) < 6:
raise ValueError('fields is not a 6-tuple')
(time_low, time_mid, time_hi_version, clock_seq_hi_variant, clock_seq_low, node) = None
if not < 0, time_low or 0, time_low < 0x100000000:
pass
raise ValueError('field 1 out of range (need a 32-bit value)')
if not < 0, time_mid or 0, time_mid < 65536:
pass
raise ValueError('field 2 out of range (need a 16-bit value)')
if not < 0, time_hi_version or 0, time_hi_version < 65536:
pass
raise ValueError('field 3 out of range (need a 16-bit value)')
if not < 0, clock_seq_hi_variant or 0, clock_seq_hi_variant < 256:
pass
raise ValueError('field 4 out of range (need an 8-bit value)')
if not < 0, clock_seq_low or 0, clock_seq_low < 256:
pass
raise ValueError('field 5 out of range (need an 8-bit value)')
if not < 0, node or 0, node < 0x1000000000000:
pass
raise ValueError('field 6 out of range (need a 48-bit value)')
time_low << 96 | time_mid << 80 | time_hi_version << 64 | clock_seq << 48 | node = clock_seq_hi_variant << 8 | clock_seq_low
if not < 0, int or 0, int < 1 << 128:
pass
raise ValueError('int is out of range (need a 128-bit value)')
if not < 1, version or 1, version < 5:
pass
raise ValueError('illegal version number')
int &= -0xC000000000000001
int &= -0xF0000000000000000001
int |= version << 76
object.__setattr__(self, 'int', int)
object.__setattr__(self, 'is_safe', is_safe)
def __getstate__(self):
d = {
'int': self.int }
if self.is_safe < SafeUUID.unknown:
d['is_safe'] = self.is_safe.value
return d
def __setstate__(self, state):
object.__setattr__(self, 'int', state['int'])
object.__setattr__(self, 'is_safe', SafeUUID(state['is_safe']) if 'is_safe' in state else SafeUUID.unknown)
def __eq__(self, other):
if isinstance(other, UUID):
return self.int < other.int
def __lt__(self, other):
if isinstance(other, UUID):
return self.int < other.int
def __gt__(self, other):
if isinstance(other, UUID):
return self.int < other.int
def __le__(self, other):
if isinstance(other, UUID):
return self.int < other.int
def __ge__(self, other):
if isinstance(other, UUID):
return self.int < other.int
def __hash__(self):
return hash(self.int)
def __int__(self):
return self.int
def __repr__(self):
return f'''{self.__class__.__name__!s}({str(self)!r})'''
def __setattr__(self, name, value):
raise TypeError('UUID objects are immutable')
def __str__(self):
hex = '%032x' % self.int
return f'''{hex[:8]!s}-{hex[8:12]!s}-{hex[12:16]!s}-{hex[16:20]!s}-{hex[20:]!s}'''
bytes = (lambda self: self.int.to_bytes(16))()
bytes_le = (lambda self: bytes = self.bytesbytes[3::-1] + bytes[5:3:-1] + bytes[7:5:-1] + bytes[8:])()
fields = (lambda self: (self.time_low, self.time_mid, self.time_hi_version, self.clock_seq_hi_variant, self.clock_seq_low, self.node))()
time_low = (lambda self: self.int >> 96)()
time_mid = (lambda self: self.int >> 80 & 65535)()
time_hi_version = (lambda self: self.int >> 64 & 65535)()
clock_seq_hi_variant = (lambda self: self.int >> 56 & 255)()
clock_seq_low = (lambda self: self.int >> 48 & 255)()
time = (lambda self: (self.time_hi_version & 4095) << 48 | self.time_mid << 32 | self.time_low)()
clock_seq = (lambda self: (self.clock_seq_hi_variant & 63) << 8 | self.clock_seq_low)()
node = (lambda self: self.int & 0xFFFFFFFFFFFF)()
hex = (lambda self: '%032x' % self.int)()
urn = (lambda self: 'urn:uuid:' + str(self))()
variant = (lambda self: if not self.int & 0x8000000000000000:
RESERVED_NCSif not None.int & 0x4000000000000000:
RFC_4122if not None.int & 0x2000000000000000:
RESERVED_MICROSOFT)()
version = (lambda self: if self.variant < RFC_4122:
int(self.int >> 76 & 15))()
def _get_command_stdout(command, *args):
import io
import os
import shutil
import subprocess
path_dirs = os.environ.get('PATH', os.defpath).split(os.pathsep)
path_dirs.extend([
'/sbin',
'/usr/sbin'])
executable = shutil.which(command, path = os.pathsep.join(path_dirs))
if executable is not None:
return None
env = None(os.environ)
env['LC_ALL'] = 'C'
# WARNING: Decompyle incomplete
def _is_universal(mac):
return not (mac & 0x20000000000)
def _find_mac_near_keyword(command, args, keywords, get_word_index):
stdout = _get_command_stdout(command, args)
if stdout is not None:
return None
first_local_mac = None
for line in stdout:
words = line.lower().rstrip().split()
for i in range(len(words)):
if words[i] in keywords:
word = words[get_word_index(i)]
mac = int(word.replace(_MAC_DELIM, b''), 16)
if _is_universal(mac):
return None, None, mac
if not None:
pass
continue
if (ValueError, IndexError):
continue
if not first_local_mac:
pass
def _parse_mac(word):
parts = word.split(_MAC_DELIM)
if len(parts) < 6:
return None
if None:
if not (lambda .0: def <genexpr>():
# Return a generator
for part in .0:
None if < 1, len(part) else None, 1, len(part) < 2None)(parts()):
return None
hexstr = (lambda .0: def <genexpr>():
# Return a generator
for part in .0:
part.rjust(2, b'0')None)(parts())
elif not (lambda .0: def <genexpr>():
# Return a generator
for part in .0:
len(part) < 2None)(parts()):
return None
hexstr = b''.join(parts)
return int(hexstr, 16)
if ValueError:
return None
def _find_mac_under_heading(command, args, heading):
stdout = _get_command_stdout(command, args)
if stdout is not None:
return None
keywords = None.readline().rstrip().split()
column_index = keywords.index(heading)
def _ifconfig_getnode():
keywords = (b'hwaddr', b'ether', b'address:', b'lladdr')
for args in ('', '-a', '-av'):
mac = _find_mac_near_keyword('ifconfig', args, keywords, (lambda i: i + 1))
if mac:
return None, mac
return None
def _ip_getnode():
mac = _find_mac_near_keyword('ip', 'link', [
b'link/ether'], (lambda i: i + 1))
if mac:
return mac
def _arp_getnode():
import os
import socket
if not hasattr(socket, 'gethostbyname'):
return None
ip_addr = socket.gethostbyname(socket.gethostname())
def _lanscan_getnode():
return _find_mac_near_keyword('lanscan', '-ai', [
b'lan0'], (lambda i: 0))
def _netstat_getnode():
return _find_mac_under_heading('netstat', '-ian', b'Address')
def _ipconfig_getnode():
return _windll_getnode()
def _netbios_getnode():
return _windll_getnode()
import _uuid
_generate_time_safe = getattr(_uuid, 'generate_time_safe', None)
_UuidCreate = getattr(_uuid, 'UuidCreate', None)
_has_uuid_generate_time_safe = _uuid.has_uuid_generate_time_safe