commit 6d16ececdd4c59437c7a6db7ab1cb030e24d627e · pyrox.dev/nixpkgs

pkgs/development/interpreters/python/2.7/default.nix

···

       44
       44
        
             ./deterministic-build.patch

     

       45
       45
        
       

     

       46
       46
        
             ./properly-detect-curses.patch

     

       47
       47
       +
           ] ++ optionals stdenv.isLinux [

     

       48
       48
       +
       

     

       49
       49
       +
             # Disable the use of ldconfig in ctypes.util.find_library (since

     

       50
       50
       +
             # ldconfig doesn't work on NixOS), and don't use

     

       51
       51
       +
             # ctypes.util.find_library during the loading of the uuid module

     

       52
       52
       +
             # (since it will do a futile invocation of gcc (!) to find

     

       53
       53
       +
             # libuuid, slowing down program startup a lot).

     

       54
       54
       +
             ./no-ldconfig.patch

     

       55
       55
       +
       

     

       47
       56
        
           ] ++ optionals stdenv.isCygwin [

     

       48
       57
        
             ./2.5.2-ctypes-util-find_library.patch

     

       49
       58
        
             ./2.5.2-tkinter-x11.patch

+97

pkgs/development/interpreters/python/2.7/no-ldconfig.patch

···

       1
       1
       +
       diff -ru -x '*~' Python-2.7.11-orig/Lib/ctypes/util.py Python-2.7.11/Lib/ctypes/util.py

     

       2
       2
       +
       --- Python-2.7.11-orig/Lib/ctypes/util.py	2015-12-05 20:46:56.000000000 +0100

     

       3
       3
       +
       +++ Python-2.7.11/Lib/ctypes/util.py	2016-07-01 14:24:50.714223450 +0200

     

       4
       4
       +
       @@ -212,31 +212,7 @@

     

       5
       5
       +
            else:

     

       6
       6
       +
        

     

       7
       7
       +
                def _findSoname_ldconfig(name):

     

       8
       8
       +
       -            import struct

     

       9
       9
       +
       -            if struct.calcsize('l') == 4:

     

       10
       10
       +
       -                machine = os.uname()[4] + '-32'

     

       11
       11
       +
       -            else:

     

       12
       12
       +
       -                machine = os.uname()[4] + '-64'

     

       13
       13
       +
       -            mach_map = {

     

       14
       14
       +
       -                'x86_64-64': 'libc6,x86-64',

     

       15
       15
       +
       -                'ppc64-64': 'libc6,64bit',

     

       16
       16
       +
       -                'sparc64-64': 'libc6,64bit',

     

       17
       17
       +
       -                's390x-64': 'libc6,64bit',

     

       18
       18
       +
       -                'ia64-64': 'libc6,IA-64',

     

       19
       19
       +
       -                }

     

       20
       20
       +
       -            abi_type = mach_map.get(machine, 'libc6')

     

       21
       21
       +
       -

     

       22
       22
       +
       -            # XXX assuming GLIBC's ldconfig (with option -p)

     

       23
       23
       +
       -            expr = r'\s+(lib%s\.[^\s]+)\s+\(%s' % (re.escape(name), abi_type)

     

       24
       24
       +
       -            f = os.popen('/sbin/ldconfig -p 2>/dev/null')

     

       25
       25
       +
       -            try:

     

       26
       26
       +
       -                data = f.read()

     

       27
       27
       +
       -            finally:

     

       28
       28
       +
       -                f.close()

     

       29
       29
       +
       -            res = re.search(expr, data)

     

       30
       30
       +
       -            if not res:

     

       31
       31
       +
       -                return None

     

       32
       32
       +
       -            return res.group(1)

     

       33
       33
       +
       +            return None

     

       34
       34
       +
        

     

       35
       35
       +
                def find_library(name):

     

       36
       36
       +
                    return _findSoname_ldconfig(name) or _get_soname(_findLib_gcc(name))

     

       37
       37
       +
       diff -ru -x '*~' Python-2.7.11-orig/Lib/uuid.py Python-2.7.11/Lib/uuid.py

     

       38
       38
       +
       --- Python-2.7.11-orig/Lib/uuid.py	2015-12-05 20:47:09.000000000 +0100

     

       39
       39
       +
       +++ Python-2.7.11/Lib/uuid.py	2016-07-01 14:33:14.360446897 +0200

     

       40
       40
       +
       @@ -437,57 +437,7 @@

     

       41
       41
       +
                return ((bytes[0]<<40L) + (bytes[1]<<32L) + (bytes[2]<<24L) +

     

       42
       42
       +
                        (bytes[3]<<16L) + (bytes[4]<<8L) + bytes[5])

     

       43
       43
       +
        

     

       44
       44
       +
       -# Thanks to Thomas Heller for ctypes and for his help with its use here.

     

       45
       45
       +
       -

     

       46
       46
       +
       -# If ctypes is available, use it to find system routines for UUID generation.

     

       47
       47
       +
        _uuid_generate_time = _UuidCreate = None

     

       48
       48
       +
       -try:

     

       49
       49
       +
       -    import ctypes, ctypes.util

     

       50
       50
       +
       -    import sys

     

       51
       51
       +
       -

     

       52
       52
       +
       -    # The uuid_generate_* routines are provided by libuuid on at least

     

       53
       53
       +
       -    # Linux and FreeBSD, and provided by libc on Mac OS X.

     

       54
       54
       +
       -    _libnames = ['uuid']

     

       55
       55
       +
       -    if not sys.platform.startswith('win'):

     

       56
       56
       +
       -        _libnames.append('c')

     

       57
       57
       +
       -    for libname in _libnames:

     

       58
       58
       +
       -        try:

     

       59
       59
       +
       -            lib = ctypes.CDLL(ctypes.util.find_library(libname))

     

       60
       60
       +
       -        except:

     

       61
       61
       +
       -            continue

     

       62
       62
       +
       -        if hasattr(lib, 'uuid_generate_time'):

     

       63
       63
       +
       -            _uuid_generate_time = lib.uuid_generate_time

     

       64
       64
       +
       -            break

     

       65
       65
       +
       -    del _libnames

     

       66
       66
       +
       -

     

       67
       67
       +
       -    # The uuid_generate_* functions are broken on MacOS X 10.5, as noted

     

       68
       68
       +
       -    # in issue #8621 the function generates the same sequence of values

     

       69
       69
       +
       -    # in the parent process and all children created using fork (unless

     

       70
       70
       +
       -    # those children use exec as well).

     

       71
       71
       +
       -    #

     

       72
       72
       +
       -    # Assume that the uuid_generate functions are broken from 10.5 onward,

     

       73
       73
       +
       -    # the test can be adjusted when a later version is fixed.

     

       74
       74
       +
       -    if sys.platform == 'darwin':

     

       75
       75
       +
       -        import os

     

       76
       76
       +
       -        if int(os.uname()[2].split('.')[0]) >= 9:

     

       77
       77
       +
       -            _uuid_generate_time = None

     

       78
       78
       +
       -

     

       79
       79
       +
       -    # On Windows prior to 2000, UuidCreate gives a UUID containing the

     

       80
       80
       +
       -    # hardware address.  On Windows 2000 and later, UuidCreate makes a

     

       81
       81
       +
       -    # random UUID and UuidCreateSequential gives a UUID containing the

     

       82
       82
       +
       -    # hardware address.  These routines are provided by the RPC runtime.

     

       83
       83
       +
       -    # NOTE:  at least on Tim's WinXP Pro SP2 desktop box, while the last

     

       84
       84
       +
       -    # 6 bytes returned by UuidCreateSequential are fixed, they don't appear

     

       85
       85
       +
       -    # to bear any relationship to the MAC address of any network device

     

       86
       86
       +
       -    # on the box.

     

       87
       87
       +
       -    try:

     

       88
       88
       +
       -        lib = ctypes.windll.rpcrt4

     

       89
       89
       +
       -    except:

     

       90
       90
       +
       -        lib = None

     

       91
       91
       +
       -    _UuidCreate = getattr(lib, 'UuidCreateSequential',

     

       92
       92
       +
       -                          getattr(lib, 'UuidCreate', None))

     

       93
       93
       +
       -except:

     

       94
       94
       +
       -    pass

     

       95
       95
       +
        

     

       96
       96
       +
        def _unixdll_getnode():

     

       97
       97
       +
            """Get the hardware address on Unix using ctypes."""