home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2839 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  13.5 KB  |  474 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __author__ = 'Ka-Ping Yee <ping@zesty.ca>'
  5. (RESERVED_NCS, RFC_4122, RESERVED_MICROSOFT, RESERVED_FUTURE) = [
  6.     'reserved for NCS compatibility',
  7.     'specified in RFC 4122',
  8.     'reserved for Microsoft compatibility',
  9.     'reserved for future definition']
  10.  
  11. class UUID(object):
  12.     
  13.     def __init__(self, hex = None, bytes = None, bytes_le = None, fields = None, int = None, version = None):
  14.         if [
  15.             hex,
  16.             bytes,
  17.             bytes_le,
  18.             fields,
  19.             int].count(None) != 4:
  20.             raise TypeError('need one of hex, bytes, bytes_le, fields, or int')
  21.         [
  22.             hex,
  23.             bytes,
  24.             bytes_le,
  25.             fields,
  26.             int].count(None) != 4
  27.         if hex is not None:
  28.             hex = hex.replace('urn:', '').replace('uuid:', '')
  29.             hex = hex.strip('{}').replace('-', '')
  30.             if len(hex) != 32:
  31.                 raise ValueError('badly formed hexadecimal UUID string')
  32.             len(hex) != 32
  33.             int = long(hex, 16)
  34.         
  35.         if bytes_le is not None:
  36.             if len(bytes_le) != 16:
  37.                 raise ValueError('bytes_le is not a 16-char string')
  38.             len(bytes_le) != 16
  39.             bytes = bytes_le[3] + bytes_le[2] + bytes_le[1] + bytes_le[0] + bytes_le[5] + bytes_le[4] + bytes_le[7] + bytes_le[6] + bytes_le[8:]
  40.         
  41.         if bytes is not None:
  42.             if len(bytes) != 16:
  43.                 raise ValueError('bytes is not a 16-char string')
  44.             len(bytes) != 16
  45.             int = long('%02x' * 16 % tuple(map(ord, bytes)), 16)
  46.         
  47.         if fields is not None:
  48.             if len(fields) != 6:
  49.                 raise ValueError('fields is not a 6-tuple')
  50.             len(fields) != 6
  51.             (time_low, time_mid, time_hi_version, clock_seq_hi_variant, clock_seq_low, node) = fields
  52.             if time_low <= time_low:
  53.                 pass
  54.             elif not time_low < 0x100000000L:
  55.                 raise ValueError('field 1 out of range (need a 32-bit value)')
  56.             
  57.             if time_mid <= time_mid:
  58.                 pass
  59.             elif not time_mid < 0x10000L:
  60.                 raise ValueError('field 2 out of range (need a 16-bit value)')
  61.             
  62.             if time_hi_version <= time_hi_version:
  63.                 pass
  64.             elif not time_hi_version < 0x10000L:
  65.                 raise ValueError('field 3 out of range (need a 16-bit value)')
  66.             
  67.             if clock_seq_hi_variant <= clock_seq_hi_variant:
  68.                 pass
  69.             elif not clock_seq_hi_variant < 0x100L:
  70.                 raise ValueError('field 4 out of range (need an 8-bit value)')
  71.             
  72.             if clock_seq_low <= clock_seq_low:
  73.                 pass
  74.             elif not clock_seq_low < 0x100L:
  75.                 raise ValueError('field 5 out of range (need an 8-bit value)')
  76.             
  77.             if node <= node:
  78.                 pass
  79.             elif not node < 0x1000000000000L:
  80.                 raise ValueError('field 6 out of range (need a 48-bit value)')
  81.             
  82.             clock_seq = clock_seq_hi_variant << 0x8L | clock_seq_low
  83.             int = time_low << 0x60L | time_mid << 0x50L | time_hi_version << 0x40L | clock_seq << 0x30L | node
  84.         
  85.         if int is not None:
  86.             if int <= int:
  87.                 pass
  88.             elif not int < 0x100000000000000000000000000000000L:
  89.                 raise ValueError('int is out of range (need a 128-bit value)')
  90.             
  91.         
  92.         if version is not None:
  93.             if version <= version:
  94.                 pass
  95.             elif not version <= 5:
  96.                 raise ValueError('illegal version number')
  97.             
  98.             int &= -0xC000000000000001L
  99.             int |= 0x8000000000000000L
  100.             int &= -0xF0000000000000000001L
  101.             int |= version << 0x4CL
  102.         
  103.         self.__dict__['int'] = int
  104.  
  105.     
  106.     def __cmp__(self, other):
  107.         if isinstance(other, UUID):
  108.             return cmp(self.int, other.int)
  109.         return NotImplemented
  110.  
  111.     
  112.     def __hash__(self):
  113.         return hash(self.int)
  114.  
  115.     
  116.     def __int__(self):
  117.         return self.int
  118.  
  119.     
  120.     def __repr__(self):
  121.         return 'UUID(%r)' % str(self)
  122.  
  123.     
  124.     def __setattr__(self, name, value):
  125.         raise TypeError('UUID objects are immutable')
  126.  
  127.     
  128.     def __str__(self):
  129.         hex = '%032x' % self.int
  130.         return '%s-%s-%s-%s-%s' % (hex[:8], hex[8:12], hex[12:16], hex[16:20], hex[20:])
  131.  
  132.     
  133.     def get_bytes(self):
  134.         bytes = ''
  135.         for shift in range(0, 128, 8):
  136.             bytes = chr(self.int >> shift & 255) + bytes
  137.         
  138.         return bytes
  139.  
  140.     bytes = property(get_bytes)
  141.     
  142.     def get_bytes_le(self):
  143.         bytes = self.bytes
  144.         return bytes[3] + bytes[2] + bytes[1] + bytes[0] + bytes[5] + bytes[4] + bytes[7] + bytes[6] + bytes[8:]
  145.  
  146.     bytes_le = property(get_bytes_le)
  147.     
  148.     def get_fields(self):
  149.         return (self.time_low, self.time_mid, self.time_hi_version, self.clock_seq_hi_variant, self.clock_seq_low, self.node)
  150.  
  151.     fields = property(get_fields)
  152.     
  153.     def get_time_low(self):
  154.         return self.int >> 0x60L
  155.  
  156.     time_low = property(get_time_low)
  157.     
  158.     def get_time_mid(self):
  159.         return self.int >> 0x50L & 65535
  160.  
  161.     time_mid = property(get_time_mid)
  162.     
  163.     def get_time_hi_version(self):
  164.         return self.int >> 0x40L & 65535
  165.  
  166.     time_hi_version = property(get_time_hi_version)
  167.     
  168.     def get_clock_seq_hi_variant(self):
  169.         return self.int >> 0x38L & 255
  170.  
  171.     clock_seq_hi_variant = property(get_clock_seq_hi_variant)
  172.     
  173.     def get_clock_seq_low(self):
  174.         return self.int >> 0x30L & 255
  175.  
  176.     clock_seq_low = property(get_clock_seq_low)
  177.     
  178.     def get_time(self):
  179.         return (self.time_hi_version & 0xFFFL) << 0x30L | self.time_mid << 0x20L | self.time_low
  180.  
  181.     time = property(get_time)
  182.     
  183.     def get_clock_seq(self):
  184.         return (self.clock_seq_hi_variant & 0x3FL) << 0x8L | self.clock_seq_low
  185.  
  186.     clock_seq = property(get_clock_seq)
  187.     
  188.     def get_node(self):
  189.         return self.int & 0xFFFFFFFFFFFFL
  190.  
  191.     node = property(get_node)
  192.     
  193.     def get_hex(self):
  194.         return '%032x' % self.int
  195.  
  196.     hex = property(get_hex)
  197.     
  198.     def get_urn(self):
  199.         return 'urn:uuid:' + str(self)
  200.  
  201.     urn = property(get_urn)
  202.     
  203.     def get_variant(self):
  204.         if not self.int & 0x8000000000000000L:
  205.             return RESERVED_NCS
  206.         if not self.int & 0x4000000000000000L:
  207.             return RFC_4122
  208.         if not self.int & 0x2000000000000000L:
  209.             return RESERVED_MICROSOFT
  210.         return RESERVED_FUTURE
  211.  
  212.     variant = property(get_variant)
  213.     
  214.     def get_version(self):
  215.         if self.variant == RFC_4122:
  216.             return int(self.int >> 0x4CL & 15)
  217.  
  218.     version = property(get_version)
  219.  
  220.  
  221. def _find_mac(command, args, hw_identifiers, get_index):
  222.     import os
  223.     for dir in [
  224.         '',
  225.         '/sbin/',
  226.         '/usr/sbin']:
  227.         executable = os.path.join(dir, command)
  228.         if not os.path.exists(executable):
  229.             continue
  230.         
  231.         
  232.         try:
  233.             cmd = 'LC_ALL=C %s %s 2>/dev/null' % (executable, args)
  234.             pipe = os.popen(cmd)
  235.         except IOError:
  236.             continue
  237.  
  238.         for line in pipe:
  239.             words = line.lower().split()
  240.             for i in range(len(words)):
  241.                 if words[i] in hw_identifiers:
  242.                     return int(words[get_index(i)].replace(':', ''), 16)
  243.             
  244.         
  245.     
  246.  
  247.  
  248. def _ifconfig_getnode():
  249.     for args in ('', '-a', '-av'):
  250.         mac = _find_mac('ifconfig', args, [
  251.             'hwaddr',
  252.             'ether'], (lambda i: i + 1))
  253.         if mac:
  254.             return mac
  255.     
  256.     import socket
  257.     ip_addr = socket.gethostbyname(socket.gethostname())
  258.     mac = _find_mac('arp', '-an', [
  259.         ip_addr], (lambda i: -1))
  260.     if mac:
  261.         return mac
  262.     mac = _find_mac('lanscan', '-ai', [
  263.         'lan0'], (lambda i: 0))
  264.     if mac:
  265.         return mac
  266.  
  267.  
  268. def _ipconfig_getnode():
  269.     import os
  270.     import re
  271.     dirs = [
  272.         '',
  273.         'c:\\windows\\system32',
  274.         'c:\\winnt\\system32']
  275.     
  276.     try:
  277.         import ctypes
  278.         buffer = ctypes.create_string_buffer(300)
  279.         ctypes.windll.kernel32.GetSystemDirectoryA(buffer, 300)
  280.         dirs.insert(0, buffer.value.decode('mbcs'))
  281.     except:
  282.         pass
  283.  
  284.     for dir in dirs:
  285.         
  286.         try:
  287.             pipe = os.popen(os.path.join(dir, 'ipconfig') + ' /all')
  288.         except IOError:
  289.             continue
  290.  
  291.         for line in pipe:
  292.             value = line.split(':')[-1].strip().lower()
  293.             if re.match('([0-9a-f][0-9a-f]-){5}[0-9a-f][0-9a-f]', value):
  294.                 return int(value.replace('-', ''), 16)
  295.         
  296.     
  297.  
  298.  
  299. def _netbios_getnode():
  300.     import win32wnet
  301.     import netbios
  302.     ncb = netbios.NCB()
  303.     ncb.Command = netbios.NCBENUM
  304.     ncb.Buffer = adapters = netbios.LANA_ENUM()
  305.     adapters._pack()
  306.     if win32wnet.Netbios(ncb) != 0:
  307.         return None
  308.     adapters._unpack()
  309.     for i in range(adapters.length):
  310.         ncb.Reset()
  311.         ncb.Command = netbios.NCBRESET
  312.         ncb.Lana_num = ord(adapters.lana[i])
  313.         if win32wnet.Netbios(ncb) != 0:
  314.             continue
  315.         
  316.         ncb.Reset()
  317.         ncb.Command = netbios.NCBASTAT
  318.         ncb.Lana_num = ord(adapters.lana[i])
  319.         ncb.Callname = '*'.ljust(16)
  320.         ncb.Buffer = status = netbios.ADAPTER_STATUS()
  321.         if win32wnet.Netbios(ncb) != 0:
  322.             continue
  323.         
  324.         status._unpack()
  325.         bytes = map(ord, status.adapter_address)
  326.         return (bytes[0] << 0x28L) + (bytes[1] << 0x20L) + (bytes[2] << 0x18L) + (bytes[3] << 0x10L) + (bytes[4] << 0x8L) + bytes[5]
  327.     
  328.  
  329. _uuid_generate_random = None
  330. _uuid_generate_time = None
  331. _UuidCreate = None
  332.  
  333. try:
  334.     import ctypes
  335.     import ctypes.util as ctypes
  336.     for libname in [
  337.         'uuid',
  338.         'c']:
  339.         
  340.         try:
  341.             lib = ctypes.CDLL(ctypes.util.find_library(libname))
  342.         except:
  343.             continue
  344.  
  345.         if hasattr(lib, 'uuid_generate_random'):
  346.             _uuid_generate_random = lib.uuid_generate_random
  347.         
  348.         if hasattr(lib, 'uuid_generate_time'):
  349.             _uuid_generate_time = lib.uuid_generate_time
  350.             continue
  351.     
  352.     
  353.     try:
  354.         lib = ctypes.windll.rpcrt4
  355.     except:
  356.         lib = None
  357.  
  358.     _UuidCreate = getattr(lib, 'UuidCreateSequential', getattr(lib, 'UuidCreate', None))
  359. except:
  360.     pass
  361.  
  362.  
  363. def _unixdll_getnode():
  364.     _buffer = ctypes.create_string_buffer(16)
  365.     _uuid_generate_time(_buffer)
  366.     return UUID(bytes = _buffer.raw).node
  367.  
  368.  
  369. def _windll_getnode():
  370.     _buffer = ctypes.create_string_buffer(16)
  371.     if _UuidCreate(_buffer) == 0:
  372.         return UUID(bytes = _buffer.raw).node
  373.  
  374.  
  375. def _random_getnode():
  376.     import random
  377.     return random.randrange(0, 0x1000000000000L) | 0x10000000000L
  378.  
  379. _node = None
  380.  
  381. def getnode():
  382.     global _node
  383.     if _node is not None:
  384.         return _node
  385.     import sys
  386.     if sys.platform == 'win32':
  387.         getters = [
  388.             _windll_getnode,
  389.             _netbios_getnode,
  390.             _ipconfig_getnode]
  391.     else:
  392.         getters = [
  393.             _unixdll_getnode,
  394.             _ifconfig_getnode]
  395.     for getter in getters + [
  396.         _random_getnode]:
  397.         
  398.         try:
  399.             _node = getter()
  400.         except:
  401.             continue
  402.  
  403.         if _node is not None:
  404.             return _node
  405.     
  406.  
  407. _last_timestamp = None
  408.  
  409. def uuid1(node = None, clock_seq = None):
  410.     global _last_timestamp
  411.     if _uuid_generate_time:
  412.         if clock_seq is clock_seq:
  413.             pass
  414.         elif clock_seq is None:
  415.             _buffer = ctypes.create_string_buffer(16)
  416.             _uuid_generate_time(_buffer)
  417.             return UUID(bytes = _buffer.raw)
  418.     import time
  419.     nanoseconds = int(time.time() * 1e+09)
  420.     timestamp = int(nanoseconds / 100) + 0x1B21DD213814000L
  421.     if timestamp <= _last_timestamp:
  422.         timestamp = _last_timestamp + 1
  423.     
  424.     _last_timestamp = timestamp
  425.     if clock_seq is None:
  426.         import random
  427.         clock_seq = random.randrange(0x4000L)
  428.     
  429.     time_low = timestamp & 0xFFFFFFFFL
  430.     time_mid = timestamp >> 0x20L & 0xFFFFL
  431.     time_hi_version = timestamp >> 0x30L & 0xFFFL
  432.     clock_seq_low = clock_seq & 0xFFL
  433.     clock_seq_hi_variant = clock_seq >> 0x8L & 0x3FL
  434.     if node is None:
  435.         node = getnode()
  436.     
  437.     return UUID(fields = (time_low, time_mid, time_hi_version, clock_seq_hi_variant, clock_seq_low, node), version = 1)
  438.  
  439.  
  440. def uuid3(namespace, name):
  441.     md5 = md5
  442.     import hashlib
  443.     hash = md5(namespace.bytes + name).digest()
  444.     return UUID(bytes = hash[:16], version = 3)
  445.  
  446.  
  447. def uuid4():
  448.     if _uuid_generate_random:
  449.         _buffer = ctypes.create_string_buffer(16)
  450.         _uuid_generate_random(_buffer)
  451.         return UUID(bytes = _buffer.raw)
  452.     
  453.     try:
  454.         import os
  455.         return UUID(bytes = os.urandom(16), version = 4)
  456.     except:
  457.         _uuid_generate_random
  458.         import random
  459.         bytes = [ chr(random.randrange(256)) for i in range(16) ]
  460.         return UUID(bytes = bytes, version = 4)
  461.  
  462.  
  463.  
  464. def uuid5(namespace, name):
  465.     sha1 = sha1
  466.     import hashlib
  467.     hash = sha1(namespace.bytes + name).digest()
  468.     return UUID(bytes = hash[:16], version = 5)
  469.  
  470. NAMESPACE_DNS = UUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8')
  471. NAMESPACE_URL = UUID('6ba7b811-9dad-11d1-80b4-00c04fd430c8')
  472. NAMESPACE_OID = UUID('6ba7b812-9dad-11d1-80b4-00c04fd430c8')
  473. NAMESPACE_X500 = UUID('6ba7b814-9dad-11d1-80b4-00c04fd430c8')
  474.