+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy (BSD style) license. See LICENSE.txt that came with
+this distribution for specifics.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+Pearu Peterson
+
+"""
+from __future__ import division, absolute_import, print_function
+
+__all__ = ['cpu']
+
+import sys, re, types
+import os
+
+if sys.version_info[0] >= 3:
+ from subprocess import getstatusoutput
+else:
+ from commands import getstatusoutput
+
+import warnings
+import platform
+
+from numpy.distutils.compat import get_exception
+
+def getoutput(cmd, successful_status=(0,), stacklevel=1):
+ try:
+ status, output = getstatusoutput(cmd)
+ except EnvironmentError:
+ e = get_exception()
+ warnings.warn(str(e), UserWarning, stacklevel=stacklevel)
+ return False, ""
+ if os.WIFEXITED(status) and os.WEXITSTATUS(status) in successful_status:
+ return True, output
+ return False, output
+
+def command_info(successful_status=(0,), stacklevel=1, **kw):
+ info = {}
+ for key in kw:
+ ok, output = getoutput(kw[key], successful_status=successful_status,
+ stacklevel=stacklevel+1)
+ if ok:
+ info[key] = output.strip()
+ return info
+
+def command_by_line(cmd, successful_status=(0,), stacklevel=1):
+ ok, output = getoutput(cmd, successful_status=successful_status,
+ stacklevel=stacklevel+1)
+ if not ok:
+ return
+ for line in output.splitlines():
+ yield line.strip()
+
+def key_value_from_command(cmd, sep, successful_status=(0,),
+ stacklevel=1):
+ d = {}
+ for line in command_by_line(cmd, successful_status=successful_status,
+ stacklevel=stacklevel+1):
+ l = [s.strip() for s in line.split(sep, 1)]
+ if len(l) == 2:
+ d[l[0]] = l[1]
+ return d
+
+class CPUInfoBase(object):
+ """Holds CPU information and provides methods for requiring
+ the availability of various CPU features.
+ """
+
+ def _try_call(self, func):
+ try:
+ return func()
+ except Exception:
+ pass
+
+ def __getattr__(self, name):
+ if not name.startswith('_'):
+ if hasattr(self, '_'+name):
+ attr = getattr(self, '_'+name)
+ if isinstance(attr, types.MethodType):
+ return lambda func=self._try_call,attr=attr : func(attr)
+ else:
+ return lambda : None
+ raise AttributeError(name)
+
+ def _getNCPUs(self):
+ return 1
+
+ def __get_nbits(self):
+ abits = platform.architecture()[0]
+ nbits = re.compile(r'(\d+)bit').search(abits).group(1)
+ return nbits
+
+ def _is_32bit(self):
+ return self.__get_nbits() == '32'
+
+ def _is_64bit(self):
+ return self.__get_nbits() == '64'
+
+class LinuxCPUInfo(CPUInfoBase):
+
+ info = None
+
+ def __init__(self):
+ if self.info is not None:
+ return
+ info = [ {} ]
+ ok, output = getoutput('uname -m')
+ if ok:
+ info[0]['uname_m'] = output.strip()
+ try:
+ fo = open('/proc/cpuinfo')
+ except EnvironmentError:
+ e = get_exception()
+ warnings.warn(str(e), UserWarning, stacklevel=2)
+ else:
+ for line in fo:
+ name_value = [s.strip() for s in line.split(':', 1)]
+ if len(name_value) != 2:
+ continue
+ name, value = name_value
+ if not info or name in info[-1]: # next processor
+ info.append({})
+ info[-1][name] = value
+ fo.close()
+ self.__class__.info = info
+
+ def _not_impl(self): pass
+
+ # Athlon
+
+ def _is_AMD(self):
+ return self.info[0]['vendor_id']=='AuthenticAMD'
+
+ def _is_AthlonK6_2(self):
+ return self._is_AMD() and self.info[0]['model'] == '2'
+
+ def _is_AthlonK6_3(self):
+ return self._is_AMD() and self.info[0]['model'] == '3'
+
+ def _is_AthlonK6(self):
+ return re.match(r'.*?AMD-K6', self.info[0]['model name']) is not None
+
+ def _is_AthlonK7(self):
+ return re.match(r'.*?AMD-K7', self.info[0]['model name']) is not None
+
+ def _is_AthlonMP(self):
+ return re.match(r'.*?Athlon\(tm\) MP\b',
+ self.info[0]['model name']) is not None
+
+ def _is_AMD64(self):
+ return self.is_AMD() and self.info[0]['family'] == '15'
+
+ def _is_Athlon64(self):
+ return re.match(r'.*?Athlon\(tm\) 64\b',
+ self.info[0]['model name']) is not None
+
+ def _is_AthlonHX(self):
+ return re.match(r'.*?Athlon HX\b',
+ self.info[0]['model name']) is not None
+
+ def _is_Opteron(self):
+ return re.match(r'.*?Opteron\b',
+ self.info[0]['model name']) is not None
+
+ def _is_Hammer(self):
+ return re.match(r'.*?Hammer\b',
+ self.info[0]['model name']) is not None
+
+ # Alpha
+
+ def _is_Alpha(self):
+ return self.info[0]['cpu']=='Alpha'
+
+ def _is_EV4(self):
+ return self.is_Alpha() and self.info[0]['cpu model'] == 'EV4'
+
+ def _is_EV5(self):
+ return self.is_Alpha() and self.info[0]['cpu model'] == 'EV5'
+
+ def _is_EV56(self):
+ return self.is_Alpha() and self.info[0]['cpu model'] == 'EV56'
+
+ def _is_PCA56(self):
+ return self.is_Alpha() and self.info[0]['cpu model'] == 'PCA56'
+
+ # Intel
+
+ #XXX
+ _is_i386 = _not_impl
+
+ def _is_Intel(self):
+ return self.info[0]['vendor_id']=='GenuineIntel'
+
+ def _is_i486(self):
+ return self.info[0]['cpu']=='i486'
+
+ def _is_i586(self):
+ return self.is_Intel() and self.info[0]['cpu family'] == '5'
+
+ def _is_i686(self):
+ return self.is_Intel() and self.info[0]['cpu family'] == '6'
+
+ def _is_Celeron(self):
+ return re.match(r'.*?Celeron',
+ self.info[0]['model name']) is not None
+
+ def _is_Pentium(self):
+ return re.match(r'.*?Pentium',
+ self.info[0]['model name']) is not None
+
+ def _is_PentiumII(self):
+ return re.match(r'.*?Pentium.*?II\b',
+ self.info[0]['model name']) is not None
+
+ def _is_PentiumPro(self):
+ return re.match(r'.*?PentiumPro\b',
+ self.info[0]['model name']) is not None
+
+ def _is_PentiumMMX(self):
+ return re.match(r'.*?Pentium.*?MMX\b',
+ self.info[0]['model name']) is not None
+
+ def _is_PentiumIII(self):
+ return re.match(r'.*?Pentium.*?III\b',
+ self.info[0]['model name']) is not None
+
+ def _is_PentiumIV(self):
+ return re.match(r'.*?Pentium.*?(IV|4)\b',
+ self.info[0]['model name']) is not None
+
+ def _is_PentiumM(self):
+ return re.match(r'.*?Pentium.*?M\b',
+ self.info[0]['model name']) is not None
+
+ def _is_Prescott(self):
+ return self.is_PentiumIV() and self.has_sse3()
+
+ def _is_Nocona(self):
+ return self.is_Intel() \
+ and (self.info[0]['cpu family'] == '6' \
+ or self.info[0]['cpu family'] == '15' ) \
+ and (self.has_sse3() and not self.has_ssse3())\
+ and re.match(r'.*?\blm\b', self.info[0]['flags']) is not None
+
+ def _is_Core2(self):
+ return self.is_64bit() and self.is_Intel() and \
+ re.match(r'.*?Core\(TM\)2\b', \
+ self.info[0]['model name']) is not None
+
+ def _is_Itanium(self):
+ return re.match(r'.*?Itanium\b',
+ self.info[0]['family']) is not None
+
+ def _is_XEON(self):
+ return re.match(r'.*?XEON\b',
+ self.info[0]['model name'], re.IGNORECASE) is not None
+
+ _is_Xeon = _is_XEON
+
+ # Varia
+
+ def _is_singleCPU(self):
+ return len(self.info) == 1
+
+ def _getNCPUs(self):
+ return len(self.info)
+
+ def _has_fdiv_bug(self):
+ return self.info[0]['fdiv_bug']=='yes'
+
+ def _has_f00f_bug(self):
+ return self.info[0]['f00f_bug']=='yes'
+
+ def _has_mmx(self):
+ return re.match(r'.*?\bmmx\b', self.info[0]['flags']) is not None
+
+ def _has_sse(self):
+ return re.match(r'.*?\bsse\b', self.info[0]['flags']) is not None
+
+ def _has_sse2(self):
+ return re.match(r'.*?\bsse2\b', self.info[0]['flags']) is not None
+
+ def _has_sse3(self):
+ return re.match(r'.*?\bpni\b', self.info[0]['flags']) is not None
+
+ def _has_ssse3(self):
+ return re.match(r'.*?\bssse3\b', self.info[0]['flags']) is not None
+
+ def _has_3dnow(self):
+ return re.match(r'.*?\b3dnow\b', self.info[0]['flags']) is not None
+
+ def _has_3dnowext(self):
+ return re.match(r'.*?\b3dnowext\b', self.info[0]['flags']) is not None
+
+class IRIXCPUInfo(CPUInfoBase):
+ info = None
+
+ def __init__(self):
+ if self.info is not None:
+ return
+ info = key_value_from_command('sysconf', sep=' ',
+ successful_status=(0, 1))
+ self.__class__.info = info
+
+ def _not_impl(self): pass
+
+ def _is_singleCPU(self):
+ return self.info.get('NUM_PROCESSORS') == '1'
+
+ def _getNCPUs(self):
+ return int(self.info.get('NUM_PROCESSORS', 1))
+
+ def __cputype(self, n):
+ return self.info.get('PROCESSORS').split()[0].lower() == 'r%s' % (n)
+ def _is_r2000(self): return self.__cputype(2000)
+ def _is_r3000(self): return self.__cputype(3000)
+ def _is_r3900(self): return self.__cputype(3900)
+ def _is_r4000(self): return self.__cputype(4000)
+ def _is_r4100(self): return self.__cputype(4100)
+ def _is_r4300(self): return self.__cputype(4300)
+ def _is_r4400(self): return self.__cputype(4400)
+ def _is_r4600(self): return self.__cputype(4600)
+ def _is_r4650(self): return self.__cputype(4650)
+ def _is_r5000(self): return self.__cputype(5000)
+ def _is_r6000(self): return self.__cputype(6000)
+ def _is_r8000(self): return self.__cputype(8000)
+ def _is_r10000(self): return self.__cputype(10000)
+ def _is_r12000(self): return self.__cputype(12000)
+ def _is_rorion(self): return self.__cputype('orion')
+
+ def get_ip(self):
+ try: return self.info.get('MACHINE')
+ except Exception: pass
+ def __machine(self, n):
+ return self.info.get('MACHINE').lower() == 'ip%s' % (n)
+ def _is_IP19(self): return self.__machine(19)
+ def _is_IP20(self): return self.__machine(20)
+ def _is_IP21(self): return self.__machine(21)
+ def _is_IP22(self): return self.__machine(22)
+ def _is_IP22_4k(self): return self.__machine(22) and self._is_r4000()
+ def _is_IP22_5k(self): return self.__machine(22) and self._is_r5000()
+ def _is_IP24(self): return self.__machine(24)
+ def _is_IP25(self): return self.__machine(25)
+ def _is_IP26(self): return self.__machine(26)
+ def _is_IP27(self): return self.__machine(27)
+ def _is_IP28(self): return self.__machine(28)
+ def _is_IP30(self): return self.__machine(30)
+ def _is_IP32(self): return self.__machine(32)
+ def _is_IP32_5k(self): return self.__machine(32) and self._is_r5000()
+ def _is_IP32_10k(self): return self.__machine(32) and self._is_r10000()
+
+
+class DarwinCPUInfo(CPUInfoBase):
+ info = None
+
+ def __init__(self):
+ if self.info is not None:
+ return
+ info = command_info(arch='arch',
+ machine='machine')
+ info['sysctl_hw'] = key_value_from_command('sysctl hw', sep='=')
+ self.__class__.info = info
+
+ def _not_impl(self): pass
+
+ def _getNCPUs(self):
+ return int(self.info['sysctl_hw'].get('hw.ncpu', 1))
+
+ def _is_Power_Macintosh(self):
+ return self.info['sysctl_hw']['hw.machine']=='Power Macintosh'
+
+ def _is_i386(self):
+ return self.info['arch']=='i386'
+ def _is_ppc(self):
+ return self.info['arch']=='ppc'
+
+ def __machine(self, n):
+ return self.info['machine'] == 'ppc%s'%n
+ def _is_ppc601(self): return self.__machine(601)
+ def _is_ppc602(self): return self.__machine(602)
+ def _is_ppc603(self): return self.__machine(603)
+ def _is_ppc603e(self): return self.__machine('603e')
+ def _is_ppc604(self): return self.__machine(604)
+ def _is_ppc604e(self): return self.__machine('604e')
+ def _is_ppc620(self): return self.__machine(620)
+ def _is_ppc630(self): return self.__machine(630)
+ def _is_ppc740(self): return self.__machine(740)
+ def _is_ppc7400(self): return self.__machine(7400)
+ def _is_ppc7450(self): return self.__machine(7450)
+ def _is_ppc750(self): return self.__machine(750)
+ def _is_ppc403(self): return self.__machine(403)
+ def _is_ppc505(self): return self.__machine(505)
+ def _is_ppc801(self): return self.__machine(801)
+ def _is_ppc821(self): return self.__machine(821)
+ def _is_ppc823(self): return self.__machine(823)
+ def _is_ppc860(self): return self.__machine(860)
+
+
+class SunOSCPUInfo(CPUInfoBase):
+
+ info = None
+
+ def __init__(self):
+ if self.info is not None:
+ return
+ info = command_info(arch='arch',
+ mach='mach',
+ uname_i='uname_i',
+ isainfo_b='isainfo -b',
+ isainfo_n='isainfo -n',
+ )
+ info['uname_X'] = key_value_from_command('uname -X', sep='=')
+ for line in command_by_line('psrinfo -v 0'):
+ m = re.match(r'\s*The (?P[\w\d]+) processor operates at', line)
+ if m:
+ info['processor'] = m.group('p')
+ break
+ self.__class__.info = info
+
+ def _not_impl(self): pass
+
+ def _is_i386(self):
+ return self.info['isainfo_n']=='i386'
+ def _is_sparc(self):
+ return self.info['isainfo_n']=='sparc'
+ def _is_sparcv9(self):
+ return self.info['isainfo_n']=='sparcv9'
+
+ def _getNCPUs(self):
+ return int(self.info['uname_X'].get('NumCPU', 1))
+
+ def _is_sun4(self):
+ return self.info['arch']=='sun4'
+
+ def _is_SUNW(self):
+ return re.match(r'SUNW', self.info['uname_i']) is not None
+ def _is_sparcstation5(self):
+ return re.match(r'.*SPARCstation-5', self.info['uname_i']) is not None
+ def _is_ultra1(self):
+ return re.match(r'.*Ultra-1', self.info['uname_i']) is not None
+ def _is_ultra250(self):
+ return re.match(r'.*Ultra-250', self.info['uname_i']) is not None
+ def _is_ultra2(self):
+ return re.match(r'.*Ultra-2', self.info['uname_i']) is not None
+ def _is_ultra30(self):
+ return re.match(r'.*Ultra-30', self.info['uname_i']) is not None
+ def _is_ultra4(self):
+ return re.match(r'.*Ultra-4', self.info['uname_i']) is not None
+ def _is_ultra5_10(self):
+ return re.match(r'.*Ultra-5_10', self.info['uname_i']) is not None
+ def _is_ultra5(self):
+ return re.match(r'.*Ultra-5', self.info['uname_i']) is not None
+ def _is_ultra60(self):
+ return re.match(r'.*Ultra-60', self.info['uname_i']) is not None
+ def _is_ultra80(self):
+ return re.match(r'.*Ultra-80', self.info['uname_i']) is not None
+ def _is_ultraenterprice(self):
+ return re.match(r'.*Ultra-Enterprise', self.info['uname_i']) is not None
+ def _is_ultraenterprice10k(self):
+ return re.match(r'.*Ultra-Enterprise-10000', self.info['uname_i']) is not None
+ def _is_sunfire(self):
+ return re.match(r'.*Sun-Fire', self.info['uname_i']) is not None
+ def _is_ultra(self):
+ return re.match(r'.*Ultra', self.info['uname_i']) is not None
+
+ def _is_cpusparcv7(self):
+ return self.info['processor']=='sparcv7'
+ def _is_cpusparcv8(self):
+ return self.info['processor']=='sparcv8'
+ def _is_cpusparcv9(self):
+ return self.info['processor']=='sparcv9'
+
+class Win32CPUInfo(CPUInfoBase):
+
+ info = None
+ pkey = r"HARDWARE\DESCRIPTION\System\CentralProcessor"
+ # XXX: what does the value of
+ # HKEY_LOCAL_MACHINE\HARDWARE\DESCRIPTION\System\CentralProcessor\0
+ # mean?
+
+ def __init__(self):
+ if self.info is not None:
+ return
+ info = []
+ try:
+ #XXX: Bad style to use so long `try:...except:...`. Fix it!
+ if sys.version_info[0] >= 3:
+ import winreg
+ else:
+ import _winreg as winreg
+
+ prgx = re.compile(r"family\s+(?P\d+)\s+model\s+(?P\d+)"
+ r"\s+stepping\s+(?P\d+)", re.IGNORECASE)
+ chnd=winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, self.pkey)
+ pnum=0
+ while True:
+ try:
+ proc=winreg.EnumKey(chnd, pnum)
+ except winreg.error:
+ break
+ else:
+ pnum+=1
+ info.append({"Processor":proc})
+ phnd=winreg.OpenKey(chnd, proc)
+ pidx=0
+ while True:
+ try:
+ name, value, vtpe=winreg.EnumValue(phnd, pidx)
+ except winreg.error:
+ break
+ else:
+ pidx=pidx+1
+ info[-1][name]=value
+ if name=="Identifier":
+ srch=prgx.search(value)
+ if srch:
+ info[-1]["Family"]=int(srch.group("FML"))
+ info[-1]["Model"]=int(srch.group("MDL"))
+ info[-1]["Stepping"]=int(srch.group("STP"))
+ except Exception:
+ print(sys.exc_info()[1], '(ignoring)')
+ self.__class__.info = info
+
+ def _not_impl(self): pass
+
+ # Athlon
+
+ def _is_AMD(self):
+ return self.info[0]['VendorIdentifier']=='AuthenticAMD'
+
+ def _is_Am486(self):
+ return self.is_AMD() and self.info[0]['Family']==4
+
+ def _is_Am5x86(self):
+ return self.is_AMD() and self.info[0]['Family']==4
+
+ def _is_AMDK5(self):
+ return self.is_AMD() and self.info[0]['Family']==5 \
+ and self.info[0]['Model'] in [0, 1, 2, 3]
+
+ def _is_AMDK6(self):
+ return self.is_AMD() and self.info[0]['Family']==5 \
+ and self.info[0]['Model'] in [6, 7]
+
+ def _is_AMDK6_2(self):
+ return self.is_AMD() and self.info[0]['Family']==5 \
+ and self.info[0]['Model']==8
+
+ def _is_AMDK6_3(self):
+ return self.is_AMD() and self.info[0]['Family']==5 \
+ and self.info[0]['Model']==9
+
+ def _is_AMDK7(self):
+ return self.is_AMD() and self.info[0]['Family'] == 6
+
+ # To reliably distinguish between the different types of AMD64 chips
+ # (Athlon64, Operton, Athlon64 X2, Semperon, Turion 64, etc.) would
+ # require looking at the 'brand' from cpuid
+
+ def _is_AMD64(self):
+ return self.is_AMD() and self.info[0]['Family'] == 15
+
+ # Intel
+
+ def _is_Intel(self):
+ return self.info[0]['VendorIdentifier']=='GenuineIntel'
+
+ def _is_i386(self):
+ return self.info[0]['Family']==3
+
+ def _is_i486(self):
+ return self.info[0]['Family']==4
+
+ def _is_i586(self):
+ return self.is_Intel() and self.info[0]['Family']==5
+
+ def _is_i686(self):
+ return self.is_Intel() and self.info[0]['Family']==6
+
+ def _is_Pentium(self):
+ return self.is_Intel() and self.info[0]['Family']==5
+
+ def _is_PentiumMMX(self):
+ return self.is_Intel() and self.info[0]['Family']==5 \
+ and self.info[0]['Model']==4
+
+ def _is_PentiumPro(self):
+ return self.is_Intel() and self.info[0]['Family']==6 \
+ and self.info[0]['Model']==1
+
+ def _is_PentiumII(self):
+ return self.is_Intel() and self.info[0]['Family']==6 \
+ and self.info[0]['Model'] in [3, 5, 6]
+
+ def _is_PentiumIII(self):
+ return self.is_Intel() and self.info[0]['Family']==6 \
+ and self.info[0]['Model'] in [7, 8, 9, 10, 11]
+
+ def _is_PentiumIV(self):
+ return self.is_Intel() and self.info[0]['Family']==15
+
+ def _is_PentiumM(self):
+ return self.is_Intel() and self.info[0]['Family'] == 6 \
+ and self.info[0]['Model'] in [9, 13, 14]
+
+ def _is_Core2(self):
+ return self.is_Intel() and self.info[0]['Family'] == 6 \
+ and self.info[0]['Model'] in [15, 16, 17]
+
+ # Varia
+
+ def _is_singleCPU(self):
+ return len(self.info) == 1
+
+ def _getNCPUs(self):
+ return len(self.info)
+
+ def _has_mmx(self):
+ if self.is_Intel():
+ return (self.info[0]['Family']==5 and self.info[0]['Model']==4) \
+ or (self.info[0]['Family'] in [6, 15])
+ elif self.is_AMD():
+ return self.info[0]['Family'] in [5, 6, 15]
+ else:
+ return False
+
+ def _has_sse(self):
+ if self.is_Intel():
+ return (self.info[0]['Family']==6 and \
+ self.info[0]['Model'] in [7, 8, 9, 10, 11]) \
+ or self.info[0]['Family']==15
+ elif self.is_AMD():
+ return (self.info[0]['Family']==6 and \
+ self.info[0]['Model'] in [6, 7, 8, 10]) \
+ or self.info[0]['Family']==15
+ else:
+ return False
+
+ def _has_sse2(self):
+ if self.is_Intel():
+ return self.is_Pentium4() or self.is_PentiumM() \
+ or self.is_Core2()
+ elif self.is_AMD():
+ return self.is_AMD64()
+ else:
+ return False
+
+ def _has_3dnow(self):
+ return self.is_AMD() and self.info[0]['Family'] in [5, 6, 15]
+
+ def _has_3dnowext(self):
+ return self.is_AMD() and self.info[0]['Family'] in [6, 15]
+
+if sys.platform.startswith('linux'): # variations: linux2,linux-i386 (any others?)
+ cpuinfo = LinuxCPUInfo
+elif sys.platform.startswith('irix'):
+ cpuinfo = IRIXCPUInfo
+elif sys.platform == 'darwin':
+ cpuinfo = DarwinCPUInfo
+elif sys.platform.startswith('sunos'):
+ cpuinfo = SunOSCPUInfo
+elif sys.platform.startswith('win32'):
+ cpuinfo = Win32CPUInfo
+elif sys.platform.startswith('cygwin'):
+ cpuinfo = LinuxCPUInfo
+#XXX: other OS's. Eg. use _winreg on Win32. Or os.uname on unices.
+else:
+ cpuinfo = CPUInfoBase
+
+cpu = cpuinfo()
+
+#if __name__ == "__main__":
+#
+# cpu.is_blaa()
+# cpu.is_Intel()
+# cpu.is_Alpha()
+#
+# print('CPU information:'),
+# for name in dir(cpuinfo):
+# if name[0]=='_' and name[1]!='_':
+# r = getattr(cpu,name[1:])()
+# if r:
+# if r!=1:
+# print('%s=%s' %(name[1:],r))
+# else:
+# print(name[1:]),
+# print()
diff --git a/venv/Lib/site-packages/numpy/distutils/exec_command.py b/venv/Lib/site-packages/numpy/distutils/exec_command.py
new file mode 100644
index 0000000..2e7b9e4
--- /dev/null
+++ b/venv/Lib/site-packages/numpy/distutils/exec_command.py
@@ -0,0 +1,330 @@
+"""
+exec_command
+
+Implements exec_command function that is (almost) equivalent to
+commands.getstatusoutput function but on NT, DOS systems the
+returned status is actually correct (though, the returned status
+values may be different by a factor). In addition, exec_command
+takes keyword arguments for (re-)defining environment variables.
+
+Provides functions:
+
+ exec_command --- execute command in a specified directory and
+ in the modified environment.
+ find_executable --- locate a command using info from environment
+ variable PATH. Equivalent to posix `which`
+ command.
+
+Author: Pearu Peterson
+Created: 11 January 2003
+
+Requires: Python 2.x
+
+Successfully tested on:
+
+======== ============ =================================================
+os.name sys.platform comments
+======== ============ =================================================
+posix linux2 Debian (sid) Linux, Python 2.1.3+, 2.2.3+, 2.3.3
+ PyCrust 0.9.3, Idle 1.0.2
+posix linux2 Red Hat 9 Linux, Python 2.1.3, 2.2.2, 2.3.2
+posix sunos5 SunOS 5.9, Python 2.2, 2.3.2
+posix darwin Darwin 7.2.0, Python 2.3
+nt win32 Windows Me
+ Python 2.3(EE), Idle 1.0, PyCrust 0.7.2
+ Python 2.1.1 Idle 0.8
+nt win32 Windows 98, Python 2.1.1. Idle 0.8
+nt win32 Cygwin 98-4.10, Python 2.1.1(MSC) - echo tests
+ fail i.e. redefining environment variables may
+ not work. FIXED: don't use cygwin echo!
+ Comment: also `cmd /c echo` will not work
+ but redefining environment variables do work.
+posix cygwin Cygwin 98-4.10, Python 2.3.3(cygming special)
+nt win32 Windows XP, Python 2.3.3
+======== ============ =================================================
+
+Known bugs:
+
+* Tests, that send messages to stderr, fail when executed from MSYS prompt
+ because the messages are lost at some point.
+
+"""
+from __future__ import division, absolute_import, print_function
+
+__all__ = ['exec_command', 'find_executable']
+
+import os
+import sys
+import subprocess
+import locale
+import warnings
+
+from numpy.distutils.misc_util import is_sequence, make_temp_file
+from numpy.distutils import log
+
+def filepath_from_subprocess_output(output):
+ """
+ Convert `bytes` in the encoding used by a subprocess into a filesystem-appropriate `str`.
+
+ Inherited from `exec_command`, and possibly incorrect.
+ """
+ mylocale = locale.getpreferredencoding(False)
+ if mylocale is None:
+ mylocale = 'ascii'
+ output = output.decode(mylocale, errors='replace')
+ output = output.replace('\r\n', '\n')
+ # Another historical oddity
+ if output[-1:] == '\n':
+ output = output[:-1]
+ # stdio uses bytes in python 2, so to avoid issues, we simply
+ # remove all non-ascii characters
+ if sys.version_info < (3, 0):
+ output = output.encode('ascii', errors='replace')
+ return output
+
+
+def forward_bytes_to_stdout(val):
+ """
+ Forward bytes from a subprocess call to the console, without attempting to
+ decode them.
+
+ The assumption is that the subprocess call already returned bytes in
+ a suitable encoding.
+ """
+ if sys.version_info.major < 3:
+ # python 2 has binary output anyway
+ sys.stdout.write(val)
+ elif hasattr(sys.stdout, 'buffer'):
+ # use the underlying binary output if there is one
+ sys.stdout.buffer.write(val)
+ elif hasattr(sys.stdout, 'encoding'):
+ # round-trip the encoding if necessary
+ sys.stdout.write(val.decode(sys.stdout.encoding))
+ else:
+ # make a best-guess at the encoding
+ sys.stdout.write(val.decode('utf8', errors='replace'))
+
+
+def temp_file_name():
+ # 2019-01-30, 1.17
+ warnings.warn('temp_file_name is deprecated since NumPy v1.17, use '
+ 'tempfile.mkstemp instead', DeprecationWarning, stacklevel=1)
+ fo, name = make_temp_file()
+ fo.close()
+ return name
+
+def get_pythonexe():
+ pythonexe = sys.executable
+ if os.name in ['nt', 'dos']:
+ fdir, fn = os.path.split(pythonexe)
+ fn = fn.upper().replace('PYTHONW', 'PYTHON')
+ pythonexe = os.path.join(fdir, fn)
+ assert os.path.isfile(pythonexe), '%r is not a file' % (pythonexe,)
+ return pythonexe
+
+def find_executable(exe, path=None, _cache={}):
+ """Return full path of a executable or None.
+
+ Symbolic links are not followed.
+ """
+ key = exe, path
+ try:
+ return _cache[key]
+ except KeyError:
+ pass
+ log.debug('find_executable(%r)' % exe)
+ orig_exe = exe
+
+ if path is None:
+ path = os.environ.get('PATH', os.defpath)
+ if os.name=='posix':
+ realpath = os.path.realpath
+ else:
+ realpath = lambda a:a
+
+ if exe.startswith('"'):
+ exe = exe[1:-1]
+
+ suffixes = ['']
+ if os.name in ['nt', 'dos', 'os2']:
+ fn, ext = os.path.splitext(exe)
+ extra_suffixes = ['.exe', '.com', '.bat']
+ if ext.lower() not in extra_suffixes:
+ suffixes = extra_suffixes
+
+ if os.path.isabs(exe):
+ paths = ['']
+ else:
+ paths = [ os.path.abspath(p) for p in path.split(os.pathsep) ]
+
+ for path in paths:
+ fn = os.path.join(path, exe)
+ for s in suffixes:
+ f_ext = fn+s
+ if not os.path.islink(f_ext):
+ f_ext = realpath(f_ext)
+ if os.path.isfile(f_ext) and os.access(f_ext, os.X_OK):
+ log.info('Found executable %s' % f_ext)
+ _cache[key] = f_ext
+ return f_ext
+
+ log.warn('Could not locate executable %s' % orig_exe)
+ return None
+
+############################################################
+
+def _preserve_environment( names ):
+ log.debug('_preserve_environment(%r)' % (names))
+ env = {name: os.environ.get(name) for name in names}
+ return env
+
+def _update_environment( **env ):
+ log.debug('_update_environment(...)')
+ for name, value in env.items():
+ os.environ[name] = value or ''
+
+def exec_command(command, execute_in='', use_shell=None, use_tee=None,
+ _with_python = 1, **env ):
+ """
+ Return (status,output) of executed command.
+
+ .. deprecated:: 1.17
+ Use subprocess.Popen instead
+
+ Parameters
+ ----------
+ command : str
+ A concatenated string of executable and arguments.
+ execute_in : str
+ Before running command ``cd execute_in`` and after ``cd -``.
+ use_shell : {bool, None}, optional
+ If True, execute ``sh -c command``. Default None (True)
+ use_tee : {bool, None}, optional
+ If True use tee. Default None (True)
+
+
+ Returns
+ -------
+ res : str
+ Both stdout and stderr messages.
+
+ Notes
+ -----
+ On NT, DOS systems the returned status is correct for external commands.
+ Wild cards will not work for non-posix systems or when use_shell=0.
+
+ """
+ # 2019-01-30, 1.17
+ warnings.warn('exec_command is deprecated since NumPy v1.17, use '
+ 'subprocess.Popen instead', DeprecationWarning, stacklevel=1)
+ log.debug('exec_command(%r,%s)' % (command,\
+ ','.join(['%s=%r'%kv for kv in env.items()])))
+
+ if use_tee is None:
+ use_tee = os.name=='posix'
+ if use_shell is None:
+ use_shell = os.name=='posix'
+ execute_in = os.path.abspath(execute_in)
+ oldcwd = os.path.abspath(os.getcwd())
+
+ if __name__[-12:] == 'exec_command':
+ exec_dir = os.path.dirname(os.path.abspath(__file__))
+ elif os.path.isfile('exec_command.py'):
+ exec_dir = os.path.abspath('.')
+ else:
+ exec_dir = os.path.abspath(sys.argv[0])
+ if os.path.isfile(exec_dir):
+ exec_dir = os.path.dirname(exec_dir)
+
+ if oldcwd!=execute_in:
+ os.chdir(execute_in)
+ log.debug('New cwd: %s' % execute_in)
+ else:
+ log.debug('Retaining cwd: %s' % oldcwd)
+
+ oldenv = _preserve_environment( list(env.keys()) )
+ _update_environment( **env )
+
+ try:
+ st = _exec_command(command,
+ use_shell=use_shell,
+ use_tee=use_tee,
+ **env)
+ finally:
+ if oldcwd!=execute_in:
+ os.chdir(oldcwd)
+ log.debug('Restored cwd to %s' % oldcwd)
+ _update_environment(**oldenv)
+
+ return st
+
+
+def _exec_command(command, use_shell=None, use_tee = None, **env):
+ """
+ Internal workhorse for exec_command().
+ """
+ if use_shell is None:
+ use_shell = os.name=='posix'
+ if use_tee is None:
+ use_tee = os.name=='posix'
+
+ if os.name == 'posix' and use_shell:
+ # On POSIX, subprocess always uses /bin/sh, override
+ sh = os.environ.get('SHELL', '/bin/sh')
+ if is_sequence(command):
+ command = [sh, '-c', ' '.join(command)]
+ else:
+ command = [sh, '-c', command]
+ use_shell = False
+
+ elif os.name == 'nt' and is_sequence(command):
+ # On Windows, join the string for CreateProcess() ourselves as
+ # subprocess does it a bit differently
+ command = ' '.join(_quote_arg(arg) for arg in command)
+
+ # Inherit environment by default
+ env = env or None
+ try:
+ # universal_newlines is set to False so that communicate()
+ # will return bytes. We need to decode the output ourselves
+ # so that Python will not raise a UnicodeDecodeError when
+ # it encounters an invalid character; rather, we simply replace it
+ proc = subprocess.Popen(command, shell=use_shell, env=env,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.STDOUT,
+ universal_newlines=False)
+ except EnvironmentError:
+ # Return 127, as os.spawn*() and /bin/sh do
+ return 127, ''
+
+ text, err = proc.communicate()
+ mylocale = locale.getpreferredencoding(False)
+ if mylocale is None:
+ mylocale = 'ascii'
+ text = text.decode(mylocale, errors='replace')
+ text = text.replace('\r\n', '\n')
+ # Another historical oddity
+ if text[-1:] == '\n':
+ text = text[:-1]
+
+ # stdio uses bytes in python 2, so to avoid issues, we simply
+ # remove all non-ascii characters
+ if sys.version_info < (3, 0):
+ text = text.encode('ascii', errors='replace')
+
+ if use_tee and text:
+ print(text)
+ return proc.returncode, text
+
+
+def _quote_arg(arg):
+ """
+ Quote the argument for safe use in a shell command line.
+ """
+ # If there is a quote in the string, assume relevants parts of the
+ # string are already quoted (e.g. '-I"C:\\Program Files\\..."')
+ if '"' not in arg and ' ' in arg:
+ return '"%s"' % arg
+ return arg
+
+############################################################
diff --git a/venv/Lib/site-packages/numpy/distutils/extension.py b/venv/Lib/site-packages/numpy/distutils/extension.py
new file mode 100644
index 0000000..935f3ee
--- /dev/null
+++ b/venv/Lib/site-packages/numpy/distutils/extension.py
@@ -0,0 +1,93 @@
+"""distutils.extension
+
+Provides the Extension class, used to describe C/C++ extension
+modules in setup scripts.
+
+Overridden to support f2py.
+
+"""
+from __future__ import division, absolute_import, print_function
+
+import sys
+import re
+from distutils.extension import Extension as old_Extension
+
+if sys.version_info[0] >= 3:
+ basestring = str
+
+
+cxx_ext_re = re.compile(r'.*[.](cpp|cxx|cc)\Z', re.I).match
+fortran_pyf_ext_re = re.compile(r'.*[.](f90|f95|f77|for|ftn|f|pyf)\Z', re.I).match
+
+class Extension(old_Extension):
+ def __init__ (
+ self, name, sources,
+ include_dirs=None,
+ define_macros=None,
+ undef_macros=None,
+ library_dirs=None,
+ libraries=None,
+ runtime_library_dirs=None,
+ extra_objects=None,
+ extra_compile_args=None,
+ extra_link_args=None,
+ export_symbols=None,
+ swig_opts=None,
+ depends=None,
+ language=None,
+ f2py_options=None,
+ module_dirs=None,
+ extra_f77_compile_args=None,
+ extra_f90_compile_args=None,):
+
+ old_Extension.__init__(
+ self, name, [],
+ include_dirs=include_dirs,
+ define_macros=define_macros,
+ undef_macros=undef_macros,
+ library_dirs=library_dirs,
+ libraries=libraries,
+ runtime_library_dirs=runtime_library_dirs,
+ extra_objects=extra_objects,
+ extra_compile_args=extra_compile_args,
+ extra_link_args=extra_link_args,
+ export_symbols=export_symbols)
+
+ # Avoid assert statements checking that sources contains strings:
+ self.sources = sources
+
+ # Python 2.4 distutils new features
+ self.swig_opts = swig_opts or []
+ # swig_opts is assumed to be a list. Here we handle the case where it
+ # is specified as a string instead.
+ if isinstance(self.swig_opts, basestring):
+ import warnings
+ msg = "swig_opts is specified as a string instead of a list"
+ warnings.warn(msg, SyntaxWarning, stacklevel=2)
+ self.swig_opts = self.swig_opts.split()
+
+ # Python 2.3 distutils new features
+ self.depends = depends or []
+ self.language = language
+
+ # numpy_distutils features
+ self.f2py_options = f2py_options or []
+ self.module_dirs = module_dirs or []
+ self.extra_f77_compile_args = extra_f77_compile_args or []
+ self.extra_f90_compile_args = extra_f90_compile_args or []
+
+ return
+
+ def has_cxx_sources(self):
+ for source in self.sources:
+ if cxx_ext_re(str(source)):
+ return True
+ return False
+
+ def has_f2py_sources(self):
+ for source in self.sources:
+ if fortran_pyf_ext_re(source):
+ return True
+ return False
+
+# class Extension
diff --git a/venv/Lib/site-packages/numpy/distutils/fcompiler/__init__.py b/venv/Lib/site-packages/numpy/distutils/fcompiler/__init__.py
new file mode 100644
index 0000000..3723470
--- /dev/null
+++ b/venv/Lib/site-packages/numpy/distutils/fcompiler/__init__.py
@@ -0,0 +1,1032 @@
+"""numpy.distutils.fcompiler
+
+Contains FCompiler, an abstract base class that defines the interface
+for the numpy.distutils Fortran compiler abstraction model.
+
+Terminology:
+
+To be consistent, where the term 'executable' is used, it means the single
+file, like 'gcc', that is executed, and should be a string. In contrast,
+'command' means the entire command line, like ['gcc', '-c', 'file.c'], and
+should be a list.
+
+But note that FCompiler.executables is actually a dictionary of commands.
+
+"""
+from __future__ import division, absolute_import, print_function
+
+__all__ = ['FCompiler', 'new_fcompiler', 'show_fcompilers',
+ 'dummy_fortran_file']
+
+import os
+import sys
+import re
+import types
+
+from numpy.compat import open_latin1
+
+from distutils.sysconfig import get_python_lib
+from distutils.fancy_getopt import FancyGetopt
+from distutils.errors import DistutilsModuleError, \
+ DistutilsExecError, CompileError, LinkError, DistutilsPlatformError
+from distutils.util import split_quoted, strtobool
+
+from numpy.distutils.ccompiler import CCompiler, gen_lib_options
+from numpy.distutils import log
+from numpy.distutils.misc_util import is_string, all_strings, is_sequence, \
+ make_temp_file, get_shared_lib_extension
+from numpy.distutils.exec_command import find_executable
+from numpy.distutils.compat import get_exception
+from numpy.distutils import _shell_utils
+
+from .environment import EnvironmentConfig
+
+__metaclass__ = type
+
+class CompilerNotFound(Exception):
+ pass
+
+def flaglist(s):
+ if is_string(s):
+ return split_quoted(s)
+ else:
+ return s
+
+def str2bool(s):
+ if is_string(s):
+ return strtobool(s)
+ return bool(s)
+
+def is_sequence_of_strings(seq):
+ return is_sequence(seq) and all_strings(seq)
+
+class FCompiler(CCompiler):
+ """Abstract base class to define the interface that must be implemented
+ by real Fortran compiler classes.
+
+ Methods that subclasses may redefine:
+
+ update_executables(), find_executables(), get_version()
+ get_flags(), get_flags_opt(), get_flags_arch(), get_flags_debug()
+ get_flags_f77(), get_flags_opt_f77(), get_flags_arch_f77(),
+ get_flags_debug_f77(), get_flags_f90(), get_flags_opt_f90(),
+ get_flags_arch_f90(), get_flags_debug_f90(),
+ get_flags_fix(), get_flags_linker_so()
+
+ DON'T call these methods (except get_version) after
+ constructing a compiler instance or inside any other method.
+ All methods, except update_executables() and find_executables(),
+ may call the get_version() method.
+
+ After constructing a compiler instance, always call customize(dist=None)
+ method that finalizes compiler construction and makes the following
+ attributes available:
+ compiler_f77
+ compiler_f90
+ compiler_fix
+ linker_so
+ archiver
+ ranlib
+ libraries
+ library_dirs
+ """
+
+ # These are the environment variables and distutils keys used.
+ # Each configuration description is
+ # (