def main(boost_dir): print "This is Python %s" % platform.python_version() print "Compiled with %s" % platform.python_compiler() print "Architecture: %s" % platform.architecture()[0] buildlibs = ["thread", "date_time"] pycomp = platform.python_compiler() if pycomp.startswith("MSC v.1400"): msvc_version = "8.0" # Visual Studio 2005 elif pycomp.startswith("MSC v.1500"): msvc_version = "9.0" # Visual Studio 2008 elif pycomp.startswith("MSC v.1600"): msvc_version = "10.0" # Visual Studio 2010 else: print "Error: Python compiled with unknown version of Visual Studio" sys.exit(0) msvc_short = msvc_version.replace(".", "") assert os.path.exists(boost_dir) old_path = os.getcwd() python_version = ".".join(platform.python_version_tuple()[:2]) python_path = get_config_var("prefix").replace("\\", "/").replace(" ", "\\ ") jamConfigText = "using msvc : %s ;\nusing python : %s : %s ;\n" % (msvc_version, python_version, python_path) os.chdir(boost_dir) jamConfig = open("tmp-config.jam", "w") jamConfig.write(jamConfigText) jamConfig.close() if not os.path.exists("bjam.exe"): os.system("bootstrap.bat") boost_version_string = getBoostVersion(boost_dir) print "Boost version: %s" % boost_version_string extra_args = ["-j8", "--user-config=%s" % jamConfig.name] assert os.path.exists("bjam.exe") if "64 bit" in platform.python_compiler(): extra_args.append("address-model=64") command = "bjam.exe {lib} stage --stagedir={stage} runtime-debugging={debug} variant={variant} link={link} {extra}" for variant, debug in (("release", "off"), ("debug", "on")): for link in ("shared", "static"): os.system( command.format( lib=" ".join("--with-%s" % lib for lib in buildlibs), stage=join(old_path), extra=" ".join(extra_args), variant=variant, debug=debug, link=link, ) ) os.remove(jamConfig.name)
def get_system_info(): """ Function to collect and display system information. """ python_info = { "version": platform.python_version(), "version_tuple:": platform.python_version_tuple(), "compiler": platform.python_compiler(), "build": platform.python_build(), } platform_info = {"platform": platform.platform(aliased=True)} os_and_hardware_info = { "uname:": platform.uname(), "system": platform.system(), "node": platform.node(), "release": platform.release(), "version": platform.version(), "machine": platform.machine(), "processor": platform.processor(), } executable_architecture_info = {"interpreter": platform.architecture(), "/bin/ls": platform.architecture("/bin/ls")} info = { "python_info": python_info, "platform_info": platform_info, "os_and_hardware_info": os_and_hardware_info, "executable_architecture_info": executable_architecture_info, } return info
def get_python_info(): ret = {} ret['argv'] = _escape_shell_args(sys.argv) ret['bin'] = sys.executable # Even though compiler/build_date are already here, they're # actually parsed from the version string. So, in the rare case of # the unparsable version string, we're still transmitting it. ret['version'] = ' '.join(sys.version.split()) ret['compiler'] = platform.python_compiler() ret['build_date'] = platform.python_build()[1] ret['version_info'] = list(sys.version_info) ret['features'] = {'openssl': OPENSSL_VERSION, 'expat': EXPAT_VERSION, 'sqlite': SQLITE_VERSION, 'tkinter': TKINTER_VERSION, 'zlib': ZLIB_VERSION, 'unicode_wide': HAVE_UCS4, 'readline': HAVE_READLINE, '64bit': IS_64BIT, 'ipv6': HAVE_IPV6, 'threading': HAVE_THREADING, 'urandom': HAVE_URANDOM} return ret
def get_machine_details(): if _debug: print 'Getting machine details...' buildno, builddate = platform.python_build() python = platform.python_version() try: unichr(100000) except ValueError: # UCS2 build (standard) unicode = 'UCS2' except NameError: unicode = None else: # UCS4 build (most recent Linux distros) unicode = 'UCS4' bits, linkage = platform.architecture() return { 'platform': platform.platform(), 'processor': platform.processor(), 'executable': sys.executable, 'implementation': getattr(platform, 'python_implementation', lambda:'n/a')(), 'python': platform.python_version(), 'compiler': platform.python_compiler(), 'buildno': buildno, 'builddate': builddate, 'unicode': unicode, 'bits': bits, }
def build_system(self): """ from https://github.com/Dreyer/pyinfo/blob/master/pyinfo.py """ system = { 'path': False, 'os_path': False, 'os_version': False, 'version': False, 'subversion': False, 'prefix': False, 'build_date': platform.python_build()[1], 'executable': False, 'compiler': platform.python_compiler(), 'api_version': False, 'implementation': platform.python_implementation(), 'system': platform.system(), } if platform.dist()[0] != '' and platform.dist()[1] != '': system['os_version'] = '%s %s (%s %s)' % ( platform.system(), platform.release(), platform.dist()[0].capitalize(), platform.dist()[1] ) else: system['os_version'] = '%s %s' % ( platform.system(), platform.release() ) if hasattr( os, 'path' ): system['os_path'] = os.environ['PATH'] if hasattr( sys, 'version' ): system['version'] = platform.python_version() if hasattr( sys, 'subversion' ): system['subversion'] = ', '.join( sys.subversion ) if hasattr( sys, 'prefix' ): system['prefix'] = sys.prefix if hasattr( sys, 'path' ): system['path'] = sys.path if hasattr( sys, 'executable' ): system['executable'] = sys.executable if hasattr( sys, 'api_version' ): system['api'] = sys.api_version self.system = system
def print_platform_info(): import platform logging.debug('*************** PLATFORM INFORMATION ************************') logging.debug('==Interpreter==') logging.debug('Version :' + platform.python_version()) logging.debug('Version tuple:' + str(platform.python_version_tuple())) logging.debug('Compiler :' + platform.python_compiler()) logging.debug('Build :' + str(platform.python_build())) logging.debug('==Platform==') logging.debug('Normal :' + platform.platform()) logging.debug('Aliased:' + platform.platform(aliased=True)) logging.debug('Terse :' + platform.platform(terse=True)) logging.debug('==Operating System and Hardware Info==') logging.debug('uname:' + str(platform.uname())) logging.debug('system :' + platform.system()) logging.debug('node :' + platform.node()) logging.debug('release :' + platform.release()) logging.debug('version :' + platform.version()) logging.debug('machine :' + platform.machine()) logging.debug('processor:' + platform.processor()) logging.debug('==Executable Architecture==') logging.debug('interpreter:' + str(platform.architecture())) logging.debug('/bin/ls :' + str(platform.architecture('/bin/ls'))) logging.debug('*******************************************************')
def _get_system_provenance(): """ return JSON string containing provenance for all things that are fixed during the runtime""" bits, linkage = platform.architecture() return dict( ctapipe_version=ctapipe.__version__, ctapipe_resources_version=ctapipe_resources.__version__, ctapipe_svc_path=os.getenv("CTAPIPE_SVC_PATH"), executable=sys.executable, platform=dict( architecture_bits=bits, architecture_linkage=linkage, machine=platform.machine(), processor=platform.processor(), node=platform.node(), version=platform.version(), system=platform.system(), release=platform.release(), libcver=platform.libc_ver(), num_cpus=psutil.cpu_count(), boot_time=Time(psutil.boot_time(), format='unix').isot, ), python=dict( version_string=sys.version, version=platform.python_version_tuple(), compiler=platform.python_compiler(), implementation=platform.python_implementation(), ), arguments=sys.argv, start_time_utc=Time.now().isot, )
def get_platform_info(output_file): print("\nSYSTEM INFORMATION", file=output_file) print("{:<20}{:>5}".format('system:', platform.system()), file=output_file) print("{:<20}{:>5}".format('node:', platform.node()), file=output_file) print("{:<20}{:>5}".format('version:', platform.version()), file=output_file) print("{:<20}{:>5}".format('processor:', platform.processor()), file=output_file) print("{:<20}{:>5}".format("python compiler:", platform.python_compiler()), file=output_file)
def _get_sysinfo(self): def linux_os(): modelCPU = subprocess.check_output('cat /proc/cpuinfo | sed -n -e ' '"0,/model name\s*:\s*/s///p" | tr -d "\n"', shell=True, universal_newlines=True) stringDesc = subprocess.check_output('lsb_release -a | sed -n -e "s/Description:\s*//p" | ' 'tr -d "\n"', shell=True, universal_newlines=True) return modelCPU, stringDesc def apple_os(): modelCPU = subprocess.check_output('sysctl -n machdep.cpu.brand_string | tr -d "\n"', shell=True, universal_newlines=True) osxVersion = subprocess.check_output('sw_vers -productVersion | tr -d "\n"', shell=True, universal_newlines=True) stringDesc = 'OS X ' + osxVersion return modelCPU, stringDesc stringDesc = platform.system() if stringDesc == 'Linux': stringCPU, stringDesc = linux_os() elif stringDesc == 'Darwin': stringCPU, stringDesc = apple_os() if self.out: self.out += '\n\n' self.out += 'compiler : %s\nsystem : %s\n'\ 'release : %s\nmachine : %s\n'\ 'processor : %s\nCPU cores : %s\ninterpreter: %s'%( platform.python_compiler(), stringDesc, platform.release(), platform.machine(), stringCPU, cpu_count(), platform.architecture()[0] )
def error_report_extra_provider(request): ts = os.times() e = request.environ if 'CONTENT_LENGTH' in e and e['CONTENT_LENGTH']: form = filter_names(request.form, ignore=( 'password', 'confirm_password' )) else: form = {} return { 'HTTP_ACCEPT_LANGUAGE': e['HTTP_ACCEPT_LANGUAGE'], 'HTTP_REFERER': e.get('HTTP_REFERER', '?'), 'HTTP_USER_AGENT': e['HTTP_USER_AGENT'], 'PATH_INFO': e['PATH_INFO'], 'REMOTE_ADDR': e['REMOTE_ADDR'], 'REQUEST_METHOD': e['REQUEST_METHOD'], 'executable': sys.executable, 'hostname': socket.gethostname(), 'http_cookies': request.cookies, 'http_form': form, 'machine': platform.machine(), 'modules': modules_info(), 'process_uptime': timedelta(seconds=time() - start_time), 'python_compiler': platform.python_compiler(), 'python_version': platform.python_version(), 'release': platform.release(), 'route_args': dict(e['route_args']), 'stime': timedelta(seconds=ts[1]), 'system': platform.system(), 'utime': timedelta(seconds=ts[0]), 'uwsgi.version': e.get('uwsgi.version', '?'), }
def get_machine_details(): if _debug: print('Getting machine details...') buildno, builddate = platform.python_build() python = platform.python_version() # XXX this is now always UCS4, maybe replace it with 'PEP393' in 3.3+? if sys.maxunicode == 65535: # UCS2 build (standard) unitype = 'UCS2' else: # UCS4 build (most recent Linux distros) unitype = 'UCS4' bits, linkage = platform.architecture() return { 'platform': platform.platform(), 'processor': platform.processor(), 'executable': sys.executable, 'implementation': getattr(platform, 'python_implementation', lambda:'n/a')(), 'python': platform.python_version(), 'compiler': platform.python_compiler(), 'buildno': buildno, 'builddate': builddate, 'unicode': unitype, 'bits': bits, }
def print_platform_info(): import platform logging.debug("*************** PLATFORM INFORMATION ************************") logging.debug("==Interpreter==") logging.debug("Version :" + platform.python_version()) logging.debug("Version tuple:" + str(platform.python_version_tuple())) logging.debug("Compiler :" + platform.python_compiler()) logging.debug("Build :" + str(platform.python_build())) logging.debug("==Platform==") logging.debug("Normal :" + platform.platform()) logging.debug("Aliased:" + platform.platform(aliased=True)) logging.debug("Terse :" + platform.platform(terse=True)) logging.debug("==Operating System and Hardware Info==") logging.debug("uname:" + str(platform.uname())) logging.debug("system :" + platform.system()) logging.debug("node :" + platform.node()) logging.debug("release :" + platform.release()) logging.debug("version :" + platform.version()) logging.debug("machine :" + platform.machine()) logging.debug("processor:" + platform.processor()) logging.debug("==Executable Architecture==") logging.debug("interpreter:" + str(platform.architecture())) logging.debug("/bin/ls :" + str(platform.architecture("/bin/ls"))) logging.debug("*******************************************************")
def get_python_info(): ret = {} ret["argv"] = _escape_shell_args(sys.argv) ret["bin"] = sys.executable # Even though compiler/build_date are already here, they're # actually parsed from the version string. So, in the rare case of # the unparsable version string, we're still transmitting it. ret["version"] = " ".join(sys.version.split()) ret["compiler"] = platform.python_compiler() ret["build_date"] = platform.python_build()[1] ret["version_info"] = list(sys.version_info) ret["features"] = { "openssl": OPENSSL_VERSION, "expat": EXPAT_VERSION, "sqlite": SQLITE_VERSION, "tkinter": TKINTER_VERSION, "zlib": ZLIB_VERSION, "unicode_wide": HAVE_UCS4, "readline": HAVE_READLINE, "64bit": IS_64BIT, "ipv6": HAVE_IPV6, "threading": HAVE_THREADING, "urandom": HAVE_URANDOM, } return ret
def get_machine_details(): import platform if _debug: print 'Getting machine details...' buildno, builddate = platform.python_build() python = platform.python_version() if python > '2.0': try: unichr(100000) except ValueError: # UCS2 build (standard) unicode = 'UCS2' else: # UCS4 build (most recent Linux distros) unicode = 'UCS4' else: unicode = None bits, linkage = platform.architecture() return { 'platform': platform.platform(), 'processor': platform.processor(), 'executable': sys.executable, 'python': platform.python_version(), 'compiler': platform.python_compiler(), 'buildno': buildno, 'builddate': builddate, 'unicode': unicode, 'bits': bits, }
def test_current_version(self): ver = Version.objects.get(pk=1) data = {} data["version"] = ver.version data["os.name"] = platform.system() data["os.arch"] = platform.machine() data["os.version"] = getOSVersion() data["python.version"] = platform.python_version() data["python.compiler"] = platform.python_compiler() data["python.build"] = platform.python_build() hit_url = reverse('registry_hit') request = self.factory.get(hit_url, data, HTTP_USER_AGENT='OMERO.test') response = views_hit(request) self.assertEqual(response.status_code, 200) self.assertEqual(response.content, '') hit = Hit.objects.get(agent_version=data["version"]) self.assertEqual(hit.agent.agent_name, 'OMERO.test') self.assertEqual(hit.os_name, data["os.name"]) self.assertEqual(hit.os_arch, data["os.arch"]) self.assertEqual(hit.os_version, data["os.version"]) self.assertEqual(hit.python_version, data["python.version"]) self.assertEqual(hit.python_compiler, data["python.compiler"][:50]) self.assertEqual(hit.python_build, data["python.build"][1])
def __probe_host_interpreter(self, *args, **kwargs): """Detects host interpreter. :param tuple args: A positinal arguments. :param dict kwargs: A keyword arguments. """ self.__host_interpreter = "" self.__host_interpreter_version = UNUSED_VERSION try: self.__host_interpreter = { 'cpython': PYTHON_CPYTHON, 'ironpython': PYTHON_IRON, 'jython': PYTHON_JYTHON, 'pypy': PYTHON_PYPY }.get(platform.python_implementation().lower(), '') self.__host_interpreter_version = self.__to_version( platform.python_version() ) python_compiler = platform.python_compiler() if python_compiler: if not self.__host_interpreter_version: self.__host_interpreter_version = Version(0, 0, 0, -1, "") self.__host_interpreter_version.info = python_compiler except Exception as e: self.__host_interpreter = "" self.__host_interpreter_version = UNUSED_VERSION if not self.__what_is_wrong: self.__what_is_wrong = repr(e) self.__is_ok = False except: self.__host_interpreter = "" self.__host_interpreter_version = UNUSED_VERSION self.__is_ok = False
def is_android(cls): if cls._is_android is not None: return cls._is_android try: # Check android platform criteria if not os.path.exists('/system/build.prop'): # Couldn't find "build.prop" file cls._is_android = False elif os.path.exists('/system/lib/libandroid_runtime.so'): # Found "libandroid_runtime.so" file log.info('Detected android system (found the "libandroid_runtime.so" file)') cls._is_android = True elif '-google' in platform.python_compiler(): # Found "-google" in the python compiler attribute log.info('Detected android system (found "-google" in the python compiler attribute)') cls._is_android = True else: log.warn('Found the "build.prop" file, but could\'t confirm if the system is running android') cls._is_android = False except Exception as ex: log.warn('Unable to check if the system is running android: %s', ex, exc_info=True) return cls._is_android
def test_arraywriters(): # Test initialize # Simple cases if machine() == 'sparc64' and python_compiler().startswith('GCC'): # bus errors on at least np 1.4.1 through 1.6.1 for complex test_types = FLOAT_TYPES + IUINT_TYPES else: test_types = NUMERIC_TYPES for klass in (SlopeInterArrayWriter, SlopeArrayWriter, ArrayWriter): for type in test_types: arr = np.arange(10, dtype=type) aw = klass(arr) assert_true(aw.array is arr) assert_equal(aw.out_dtype, arr.dtype) assert_array_equal(arr, round_trip(aw)) # Byteswapped is OK bs_arr = arr.byteswap().newbyteorder('S') bs_aw = klass(bs_arr) # assert against original array because POWER7 was running into # trouble using the byteswapped array (bs_arr) assert_array_equal(arr, round_trip(bs_aw)) bs_aw2 = klass(bs_arr, arr.dtype) assert_array_equal(arr, round_trip(bs_aw2)) # 2D array arr2 = np.reshape(arr, (2, 5)) a2w = klass(arr2) # Default out - in order is Fortran arr_back = round_trip(a2w) assert_array_equal(arr2, arr_back) arr_back = round_trip(a2w, 'F') assert_array_equal(arr2, arr_back) # C order works as well arr_back = round_trip(a2w, 'C') assert_array_equal(arr2, arr_back) assert_true(arr_back.flags.c_contiguous)
def test_old_version(self): ver = Version.objects.get(pk=1) data = {} data["version"] = '0.0.0' data["os.name"] = platform.system() data["os.arch"] = platform.machine() data["os.version"] = getOSVersion() data["python.version"] = platform.python_version() data["python.compiler"] = platform.python_compiler() data["python.build"] = platform.python_build() hit_url = reverse('registry_hit') request = self.factory.get(hit_url, data, HTTP_USER_AGENT='OMERO.test') response = views_hit(request) self.assertEqual(response.status_code, 200) self.assertEqual( response.content, ('Please upgrade to %s. See ' 'http://downloads.openmicroscopy.org/latest-stable/omero' ' for the latest version.') % ver.version) hit = Hit.objects.get(agent_version=data["version"]) self.assertEqual(hit.agent.agent_name, 'OMERO.test') self.assertEqual(hit.os_name, data["os.name"]) self.assertEqual(hit.os_arch, data["os.arch"]) self.assertEqual(hit.os_version, data["os.version"]) self.assertEqual(hit.python_version, data["python.version"]) self.assertEqual(hit.python_compiler, data["python.compiler"][:50]) self.assertEqual(hit.python_build, data["python.build"][1])
def get_system_details(): """Return a dictionary with information about the system """ buildno, builddate = platform.python_build() python = platform.python_version() if sys.maxunicode == 65535: # UCS2 build (standard) unitype = 'UCS2' else: # UCS4 build (most recent Linux distros) unitype = 'UCS4' bits, linkage = platform.architecture() from . import ctwrapper return { 'platform': platform.platform(), 'processor': platform.processor(), 'executable': sys.executable, 'implementation': getattr(platform, 'python_implementation', lambda:'n/a')(), 'python': platform.python_version(), 'compiler': platform.python_compiler(), 'buildno': buildno, 'builddate': builddate, 'unicode': unitype, 'bits': bits, 'visa': get_library_paths(ctwrapper) }
def __init__(self): # Linux if( sys.platform == "linux2" ): self.type = "Linux" # MacOs if( sys.platform == "mac" or sys.platform == "darwin" ): self.type = "Darwin" # Windows if( sys.platform == "win32" ): self.type = "Win" if( self.type == "Linux" ): # description out=getstatusoutput("lsb_release -d") if( out[0] == 0 ): self.ver=out[1].split("Description:")[1].strip() # hardware platform out=getstatusoutput("uname -i") if( out[0] == 0 ): self.platform=out[1].strip() try: sizeofint = platform.architecture()[0] # major minor version of compiler gccver = ''.join( platform.python_compiler().split()[-1].split('.')[:2] ) self.arch = 'gcc' + gccver + '_' + sizeofint except: pass
def main(): nltk.download('stopwords') nltk.download('vader_lexicon') print("\n================================================================================\n") print("---------------------------------- Platform Information ------------------------") print('machine: {}'.format(platform.machine())) print('node: {}'.format(platform.node())) print('processor: {}'.format(platform.processor())) print('release: {}'.format(platform.release())) print('system: {}'.format(platform.system())) print('version: {}'.format(platform.version())) print('uname: {}'.format(platform.uname())) #mem = virtual_memory() #print('memory: {}'.format(mem.total)) # total physical memory available print('python_build: {}'.format(platform.python_build())) print('python_compiler: {}'.format(platform.python_compiler())) print('python_branch: {}'.format(platform.python_branch())) print('python_implementation: {}'.format(platform.python_implementation())) print('python_revision: {}'.format(platform.python_revision())) print('python_version: {}'.format(platform.python_version())) print("\n================================================================================\n")
def display_platform_information(): """ Display platform information. """ import platform output_string = '\n-- INFORMATION: PLATFORM & OS ---------\n' try: output_string = add_param_to_output(output_string, 'OS', platform.platform()) output_string = add_param_to_output(output_string, 'OS release version', platform.version()) output_string = add_param_to_output(output_string, 'machine', platform.machine()) output_string = add_param_to_output(output_string, 'node', platform.node()) output_string = add_param_to_output(output_string, 'python version', platform.python_version()) output_string = add_param_to_output(output_string, 'python build', platform.python_build()) output_string = add_param_to_output(output_string, 'python compiler', platform.python_compiler()) except Exception: output_string += 'Some platform information cannot be displayed\n' output_string += '----------------------------------------' neon_logger.display(output_string)
def report(self, *args): report = "" report += self.entry.text.replace("(optional)", "") + "\n\n---\n\n" report += "**Application:** {0}\n".format(APP_NAME) report += "**Version:** {0}\n".format(APP_VERSION) report += "**Platform:** {0}\n".format(platform) report += "**Distro:** {0}\n".format(platfm.dist()) report += "**OS release:** {0}\n".format(platfm.release()) if platform == "macosx": report += "**Mac version:** {0}\n".format(platfm.mac_ver) if platform == "win": report += "**Win32 version:** {0}\n".format(platfm.win32_ver()) report += "**Uname:** {0}\n".format(platfm.uname()) report += "**Python version:** {0}\n".format(platfm.python_version()) report += "**Python branch:** {0}\n".format(platfm.python_branch()) report += "**Python revision:** {0}\n".format(platfm.python_revision()) report += "**Python build:** {0}\n".format(platfm.python_build()) report += "**Python implementation:** {0}\n".format(platfm.python_implementation()) report += "**Python compiler:** {0}\n".format(platfm.python_compiler()) report += "**Kivy version:** {0}\n".format(kivy.__version__) report += "**Prefix:** {0}\n".format(sys.prefix) report += "\n\n---\n\n<pre>\n" report += self.exception report += "</pre>" exc = traceback.format_exception_only(*self.exc_info[0:2])[0].split(":")[0] last = traceback.format_tb(self.exc_info[-1])[-1].replace(" File", "file").split("\n")[0].replace(misc.home, "~") title = "{exception} in {file}".format(exception=exc, file=last) from urllib import quote open_url("https://github.com/Davideddu/Karaokivy/issues/new?title={title}&body={body}&labels=bug".format(title=quote(title), body=quote(report))) self.quit()
def main(): print("platform.architecture: {}".format(p.architecture())); print("platform.machine: {}".format(p.machine())); print("platform.node: {}".format(p.node())); print("platform.processor: {}".format(p.processor())); print("platform.python_build: {}".format(p.python_build())); print("platform.python_compiler: {}".format(p.python_compiler())); print("platform.python_branch: {}".format(p.python_branch())); print("platform.python_implementation: {}".format(p.python_implementation())); print("platform.python_revision: {}".format(p.python_revision())); print("platform.python_version: {}".format(p.python_version())); print("platform.python_version_tuple: {}".format(p.python_version_tuple())); print("platform.release: {}".format(p.release())); print("platform.system: {}".format(p.system())); #print("platform.system_alias: {}".format(p.system_alias())); print("platform.version: {}".format(p.version())); print("platform.uname: {}".format(p.uname())); print("platform.win32_ver: {}".format(p.win32_ver()));
def makeLog(): msg = '' msg += "sys.version = %s\n" % (sys.version) msg += "sys.version_info = %s\n" % (str(sys.version_info)) msg += "machine = %s\n" % (platform.machine()) msg += "platform = %s\n" % (platform.platform()) msg += "processor = %s\n" % (platform.processor()) msg += "architecure = %s\n" % (str(platform.architecture())) #msg += "os = %s\n" %(platform.os()) msg += "python_branch = %s\n" % (platform.python_branch()) msg += "python_revision = %s\n" % (platform.python_revision()) msg += "win32_ver = %s\n" % (str(platform.win32_ver())) msg += "version = %s\n" % (platform.version()) msg += "uname = %s\n" % (str(platform.uname())) msg += "system = %s\n" % (platform.system()) msg += "python_build = %s\n" % (str(platform.python_build())) msg += "python_compiler = %s\n" % (platform.python_compiler()) msg += "python_implementation = %s\n" % (platform.python_implementation()) msg += "system = %s\n" % (platform.system()) #msg += "system_alias = %s\n" %(platform.system_alias()) msg += "mac_ver = %s\n" % (str(platform.mac_ver())) msg += "linux_distribution = %s\n" % ( str(platform.linux_distribution())) msg += "libc_ver = %s\n" % (str(platform.libc_ver())) print msg f = open('pyNastran.log', 'w') f.write(msg) f.close()
def get_python_info(f): """ This function will capture specific Python information, such as version number, compiler, and build. """ f.write('\n\n================PYTHON INFORMATION================\n') f.write('Python Version: ') vers = platform.python_version() f.write(vers) split_vers = vers.split('.') f_zero = float(split_vers[0]) f_one = float(split_vers[1]) if ((f_zero != 2) or (f_one < 7)): f.write('\nERROR: OpenMDAO WILL NOT WORK with a python version before 2.7 or after 3.0') f.write('\n') f.write('Python Compiler: ') f.write(platform.python_compiler()) f.write('\n') f.write('Python Build: ') f.write(str(platform.python_build())) f.write('\n') f.write('Python Path: \n') for subp in sys.path: f.write(" "+str(subp)+"\n") f.write('\n')
def TestPlatform( ): print ("----------Operation System--------------------------") # 取得 python 版本 print '取得 python 版本 : ' + platform.python_version() # 取得操作系統可執行結構 : ex('64bit','WindowsPE') print "取得操作系統可執行結構 : ex('64bit','WindowsPE')" print platform.architecture() # 電腦目前網路群組名稱 print '電腦目前網路群組名稱' + platform.node() # 獲取操作系統名稱及版本號,‘Windows-7-6.1.7601-SP1’ print '獲取操作系統名稱及版本號 : ' + platform.platform() # 電腦處理器資訊,’Intel64 Family 6 Model 42 Stepping 7, GenuineIntel’ print '電腦處理器資訊 : ' + platform.processor() # 獲取操作系統中 Python 的構建日期 print "獲取操作系統中 Python 的構建日期" print platform.python_build() # 獲取系統中 python 解釋器的信息 print '獲取系統中 python 解釋器的信息 : ' + platform.python_compiler() if platform.python_branch()=="": print platform.python_implementation() print platform.python_revision() print "platform.release : " + platform.release() print "platform.system : " + platform.system() #print platform.system_alias() # 獲取操作系統版本 print '獲取操作系統版本 : ' + platform.version()
def print_python_env(): print('-------------------------------------------------------------') print('Interpreter') print('platform.python_version: ', platform.python_version()) print('platform.python_compiler: ', platform.python_compiler()) print('platform.python_build: ', platform.python_build()) print() print('Platform') print('platform.platform(Normal): ', platform.platform()) print('platform.platform(Aliased): ', platform.platform(aliased=True)) print('platform.platform(Terse): ', platform.platform(terse=True)) print() print('Operating System and Hardware Info') print('platform.uname: ', platform.uname()) print('platform.system: ', platform.system()) print('platform.node: ', platform.node()) print('platform.release: ', platform.release()) print('platform.version: ', platform.version()) print('platform.machine: ', platform.machine()) print('platform.processor: ', platform.processor()) print() print('Executable Architecture') print('platform.architecture: ', platform.architecture()) #print() #print('OS') #print('os.uname: ', os.uname()) #print('os.getcwd: ', os.getcwd()) print() print('Network') print('socket.gethostname: ', socket.gethostname()) print('socket.gethostbyname ', socket.gethostbyname(socket.gethostname())) print('-------------------------------------------------------------')
def get_system_details(visa=True): """Return a dictionary with information about the system """ buildno, builddate = platform.python_build() if sys.maxunicode == 65535: # UCS2 build (standard) unitype = 'UCS2' else: # UCS4 build (most recent Linux distros) unitype = 'UCS4' bits, linkage = platform.architecture() d = { 'platform': platform.platform(), 'processor': platform.processor(), 'executable': sys.executable, 'implementation': getattr(platform, 'python_implementation', lambda: 'n/a')(), 'python': platform.python_version(), 'compiler': platform.python_compiler(), 'buildno': buildno, 'builddate': builddate, 'unicode': unitype, 'bits': bits, 'pyvisa': __version__ } if visa: from . import ctwrapper d['visa'] = ctwrapper.WRAPPER_CLASS.get_library_paths(LibraryPath, read_user_library_path()) return d
def __init__(self): self.logListeners = [] self.eventListeners = [] self.NativeLog = True self.buffer = "" self.data = deque() self.maxlength = 5000 self.ctrl = DummyLogCtrl() log = self class StdOut: def write(self, data): log.Write(data, INFO_ICON) if eg.debugLevel: try: oldStdOut.write(data) except: oldStdOut.write(data.decode("mbcs")) class StdErr: def write(self, data): log.Write(data, ERROR_ICON) if eg.debugLevel: try: oldStdErr.write(data) except: oldStdErr.write(data.decode("mbcs")) if eg.startupArguments.isMain: sys.stdout = StdOut() sys.stderr = StdErr() if eg.debugLevel == 2: if hasattr(_oldStdErr, "_displayMessage"): _oldStdErr._displayMessage = False if eg.debugLevel: import platform import warnings warnings.simplefilter('error', UnicodeWarning) self.PrintDebugNotice("----------------------------------------") self.PrintDebugNotice(" {0} started".format(eg.APP_NAME)) self.PrintDebugNotice("----------------------------------------") self.PrintDebugNotice(eg.APP_NAME, "Version:", eg.Version.string) self.PrintDebugNotice("Machine type:", platform.machine()) self.PrintDebugNotice("Processor:", platform.processor()) self.PrintDebugNotice("Architecture:", platform.architecture()) self.PrintDebugNotice( "Python:", platform.python_branch(), platform.python_version(), platform.python_implementation(), platform.python_build(), "[{0}]".format(platform.python_compiler()) ) self.PrintDebugNotice("----------------------------------------") # redirect all wxPython error messages to our log class MyLog(wx.PyLog): def DoLog(self, level, msg, dummyTimestamp): if (level >= 6): return sys.stderr.write("wxError%d: %s\n" % (level, msg)) wx.Log.SetActiveTarget(MyLog())
pixel_wand.load(library, IM_VERSION.value, IM_QUANTUM_DEPTH.value, IM_HDRI) drawing_wand.load(library, IM_VERSION.value) del IM_HDRI, IM_QUANTUM_DEPTH, IM_VERSION except AttributeError: raise ImportError('MagickWand shared library not found or incompatible\n' 'Original exception was raised in:\n' + traceback.format_exc()) #: (:class:`ctypes.CDLL`) The C standard library. libc = None if platform.system() == 'Windows': msvcrt = ctypes.util.find_msvcrt() # workaround -- the newest visual studio DLL is named differently: if not msvcrt and '1900' in platform.python_compiler(): msvcrt = 'vcruntime140.dll' if msvcrt: libc = ctypes.CDLL(msvcrt) else: libc_path = ctypes.util.find_library('c') if libc_path: libc = ctypes.cdll.LoadLibrary(libc_path) else: # Attempt to guess popular versions of libc libc_paths = ('libc.so.6', 'libc.so', 'libc.a', 'libc.dylib', '/usr/lib/libc.dylib') for libc_path in libc_paths: try: libc = ctypes.cdll.LoadLibrary(libc_path) break
# -*- coding: utf-8 -*- from setuptools import setup, Extension from glob import glob import platform import io import os if platform.python_compiler().startswith("MSC"): args = ["/std:c++17"] else: args = ["-std=c++17", "-flto", "-Wno-date-time"] args.extend(["-DLARGEBOARDS", "-DPRECOMPUTED_MAGICS", "-DNNUE_EMBEDDING_OFF"]) if "64bit" in platform.architecture(): args.append("-DIS_64BIT") CLASSIFIERS = [ "Development Status :: 3 - Alpha", "License :: OSI Approved :: GNU General Public License v3 (GPLv3)", "Programming Language :: Python :: 3", "Operating System :: OS Independent", ] with io.open("README.md", "r", encoding="utf8") as fh: long_description = fh.read().strip() sources = glob("src/*.cpp") + glob("src/syzygy/*.cpp") + glob( "src/nnue/*.cpp") + glob("src/nnue/features/*.cpp") ffish_source_file = os.path.normcase("src/ffishjs.cpp")
import sys import platform from time import ctime from rich.console import Console # Define styled print print = Console().print purple = "blue_violet" yellow = "yellow1" red = "red3" """ This function will stop the program when a critical error occurs """ py_version = platform.python_version() py_build = "{}, DATE: {}".format(*platform.python_build()) py_compiler = platform.python_compiler() script_location = os.path.dirname(os.path.realpath(sys.argv[0])) current_location = os.getcwd() system = platform.system() system_realese = platform.release() system_version = platform.version() system_architecture = {"{} {}".format(*platform.architecture())} system_processor = platform.processor() system_machine = platform.machine() system_node = platform.node() system_time = ctime() def CriticalError(message, error): print(f"""
def get_sys_info(): # delay these imports until now as they are only needed in this # function which then exits. import platform import json from numba import cuda as cu from numba.cuda import cudadrv from numba.cuda.cudadrv.driver import driver as cudriver import textwrap as tw import ctypes as ct import llvmlite.binding as llvmbind import locale from datetime import datetime from itertools import chain from subprocess import check_output, CalledProcessError try: fmt = "%-21s : %-s" print("-" * 80) print("__Time Stamp__") print(datetime.utcnow()) print("") print("__Hardware Information__") print(fmt % ("Machine", platform.machine())) print(fmt % ("CPU Name", llvmbind.get_host_cpu_name())) features = sorted([ key for key, value in llvmbind.get_host_cpu_features().items() if value ]) cpu_feat = tw.fill(' '.join(features), 80) print(fmt % ("CPU Features", "")) print(cpu_feat) print("") print("__OS Information__") print(fmt % ("Platform", platform.platform(aliased=True))) print(fmt % ("Release", platform.release())) system_name = platform.system() print(fmt % ("System Name", system_name)) print(fmt % ("Version", platform.version())) try: if system_name == 'Linux': info = platform.linux_distribution() elif system_name == 'Windows': info = platform.win32_ver() elif system_name == 'Darwin': info = platform.mac_ver() else: raise RuntimeError("Unknown system.") buf = ''.join([ x if x != '' else ' ' for x in list(chain.from_iterable(info)) ]) print(fmt % ("OS specific info", buf)) if system_name == 'Linux': print(fmt % ("glibc info", ' '.join(platform.libc_ver()))) except: print("Error: System name incorrectly identified or unknown.") print("") print("__Python Information__") print(fmt % ("Python Compiler", platform.python_compiler())) print(fmt % ("Python Implementation", platform.python_implementation())) print(fmt % ("Python Version", platform.python_version())) print(fmt % ("Python Locale ", ' '.join( [x for x in locale.getdefaultlocale() if x is not None]))) print("") print("__LLVM information__") print(fmt % ("LLVM version", '.'.join( [str(k) for k in llvmbind.llvm_version_info]))) print("") print("__CUDA Information__") # Look for GPUs try: cu.list_devices()[0] # will a device initialise? except BaseException as e: msg_not_found = "CUDA driver library cannot be found" msg_disabled_by_user = "******" msg_end = " or no CUDA enabled devices are present." msg_generic_problem = "Error: CUDA device intialisation problem." msg = getattr(e, 'msg', None) if msg is not None: if msg_not_found in msg: err_msg = msg_not_found + msg_end elif msg_disabled_by_user in msg: err_msg = msg_disabled_by_user + msg_end else: err_msg = msg_generic_problem + " Message:" + msg else: err_msg = msg_generic_problem + " " + str(e) # Best effort error report print("%s\nError class: %s" % (err_msg, str(type(e)))) else: try: cu.detect() dv = ct.c_int(0) cudriver.cuDriverGetVersion(ct.byref(dv)) print(fmt % ("CUDA driver version", dv.value)) print("CUDA libraries:") cudadrv.libs.test(sys.platform, print_paths=False) except: print( "Error: Probing CUDA failed (device and driver present, runtime problem?)\n" ) # Look for conda and conda information print("") print("__Conda Information__") cmd = ["conda", "info", "--json"] try: conda_out = check_output(cmd) except Exception as e: print("Conda not present/not working.\nError was %s\n" % e) else: data = ''.join(conda_out.decode("utf-8").splitlines()) jsond = json.loads(data) keys = [ 'conda_build_version', 'conda_env_version', 'platform', 'python_version', 'root_writable' ] for k in keys: try: print(fmt % (k, jsond[k])) except KeyError: pass # get info about current environment cmd = ["conda", "list"] try: conda_out = check_output(cmd) except CalledProcessError as e: print("Error: Conda command failed. Error was %s\n" % e.output) else: print("") print("__Current Conda Env__") data = conda_out.decode("utf-8").splitlines() for k in data: if k[0] != '#': # don't show where the env is, personal data print(k) print("-" * 80) except Exception as e: print("Error: The system reporting tool has failed unexpectedly.") print("Exception was:") print(e) finally: print( "%s" % "If requested, please copy and paste the information between\n" "the dashed (----) lines, or from a given specific section as\n" "appropriate.\n\n" "=============================================================\n" "IMPORTANT: Please ensure that you are happy with sharing the\n" "contents of the information present, any information that you\n" "wish to keep private you should remove before sharing.\n" "=============================================================\n")
fp.write(script) here = os.path.abspath(os.path.dirname(__file__)) # Package meta-data. NAME = 'plasticity' DESCRIPTION = 'Unsupervised Neural Networks with biological-inspired learning rules' URL = 'https://github.com/Nico-Curti/plasticity' EMAIL = '[email protected], [email protected], [email protected], [email protected]' AUTHOR = 'Nico Curti, Lorenzo Squadrani, Simone Gasperini, Mattia Ceccarelli' REQUIRES_PYTHON = '>=3.5' VERSION = None KEYWORDS = 'neural-networks deep-neural-networks deep-learning image-classification' CPP_COMPILER = platform.python_compiler() README_FILENAME = os.path.join(here, 'README.md') REQUIREMENTS_FILENAME = os.path.join(here, 'requirements.txt') VERSION_FILENAME = os.path.join(here, 'plasticity', '__version__.py') ENABLE_OMP = False if '--omp' in sys.argv: ENABLE_OMP = True sys.argv.remove('--omp') # Import the README and use it as the long-description. # Note: this will only work if 'README.md' is present in your MANIFEST.in file! try: LONG_DESCRIPTION = read_description(README_FILENAME)
try: try: readme_content = f.read() except: readme_content = "" finally: f.close() # PYTHON-654 - Clang doesn't support -mno-fused-madd but the pythons Apple # ships are built with it. This is a problem starting with Xcode 5.1 # since clang 3.4 errors out when it encounters unrecognized compiler # flags. This hack removes -mno-fused-madd from the CFLAGS automatically # generated by distutils for Apple provided pythons, allowing C extension # builds to complete without error. The inspiration comes from older # versions of distutils.sysconfig.get_config_vars. if sys.platform == 'darwin' and 'clang' in platform.python_compiler().lower(): from distutils.sysconfig import get_config_vars res = get_config_vars() for key in ('CFLAGS', 'PY_CFLAGS'): if key in res: flags = res[key] flags = re.sub('-mno-fused-madd', '', flags) res[key] = flags class test(Command): description = "run the tests" user_options = [ ("test-module=", "m", "Discover tests in specified module"), ("test-suite=", "s",
import os import platform print "-" * 80 #platform specifics # see http://docs.python.org/library/platform.html print "Platform ", platform.platform() print "Architecture ", platform.architecture() print "Machine ", platform.machine() print "--" #python specifics print "Python build ", platform.python_build() print "Python compiler ", platform.python_compiler() print "--" #osg specifics try: try: import osg except: print "import osg failed" print "osg.osgGetLibraryName ", osg.osgGetLibraryName() print "osg.osgGetVersion ", osg.osgGetVersion() print "osg.osgGetSOVersion ", osg.osgGetSOVersion() print "osg Python library location : ", osg.__file__ print "osg Dynamic linked library location : ", osg._osg
def test_sys_version(self): # Old test. for input, output in ( ('2.4.3 (#1, Jun 21 2006, 13:54:21) \n[GCC 3.3.4 (pre 3.3.5 20040809)]', ('CPython', '2.4.3', '', '', '1', 'Jun 21 2006 13:54:21', 'GCC 3.3.4 (pre 3.3.5 20040809)')), ('IronPython 1.0.60816 on .NET 2.0.50727.42', ('IronPython', '1.0.60816', '', '', '', '', '.NET 2.0.50727.42')), ('IronPython 1.0 (1.0.61005.1977) on .NET 2.0.50727.42', ('IronPython', '1.0.0', '', '', '', '', '.NET 2.0.50727.42')), ('2.4.3 (truncation, date, t) \n[GCC]', ('CPython', '2.4.3', '', '', 'truncation', 'date t', 'GCC')), ('2.4.3 (truncation, date, ) \n[GCC]', ('CPython', '2.4.3', '', '', 'truncation', 'date', 'GCC')), ('2.4.3 (truncation, date,) \n[GCC]', ('CPython', '2.4.3', '', '', 'truncation', 'date', 'GCC')), ('2.4.3 (truncation, date) \n[GCC]', ('CPython', '2.4.3', '', '', 'truncation', 'date', 'GCC')), ('2.4.3 (truncation, d) \n[GCC]', ('CPython', '2.4.3', '', '', 'truncation', 'd', 'GCC')), ('2.4.3 (truncation, ) \n[GCC]', ('CPython', '2.4.3', '', '', 'truncation', '', 'GCC')), ('2.4.3 (truncation,) \n[GCC]', ('CPython', '2.4.3', '', '', 'truncation', '', 'GCC')), ('2.4.3 (truncation) \n[GCC]', ('CPython', '2.4.3', '', '', 'truncation', '', 'GCC')), ): # branch and revision are not "parsed", but fetched # from sys._mercurial. Ignore them (name, version, branch, revision, buildno, builddate, compiler) \ = platform._sys_version(input) self.assertEqual( (name, version, '', '', buildno, builddate, compiler), output) # Tests for python_implementation(), python_version(), python_branch(), # python_revision(), python_build(), and python_compiler(). sys_versions = { ("2.6.1 (r261:67515, Dec 6 2008, 15:26:00) \n[GCC 4.0.1 (Apple Computer, Inc. build 5370)]", ('CPython', 'tags/r261', '67515'), self.save_platform): ("CPython", "2.6.1", "tags/r261", "67515", ('r261:67515', 'Dec 6 2008 15:26:00'), 'GCC 4.0.1 (Apple Computer, Inc. build 5370)'), ("IronPython 2.0 (2.0.0.0) on .NET 2.0.50727.3053", None, "cli"): ("IronPython", "2.0.0", "", "", ("", ""), ".NET 2.0.50727.3053"), ("2.6.1 (IronPython 2.6.1 (2.6.10920.0) on .NET 2.0.50727.1433)", None, "cli"): ("IronPython", "2.6.1", "", "", ("", ""), ".NET 2.0.50727.1433"), ("2.7.4 (IronPython 2.7.4 (2.7.0.40) on Mono 4.0.30319.1 (32-bit))", None, "cli"): ("IronPython", "2.7.4", "", "", ("", ""), "Mono 4.0.30319.1 (32-bit)"), ("2.5 (trunk:6107, Mar 26 2009, 13:02:18) \n[Java HotSpot(TM) Client VM (\"Apple Computer, Inc.\")]", ('Jython', 'trunk', '6107'), "java1.5.0_16"): ("Jython", "2.5.0", "trunk", "6107", ('trunk:6107', 'Mar 26 2009'), "java1.5.0_16"), ("2.5.2 (63378, Mar 26 2009, 18:03:29)\n[PyPy 1.0.0]", ('PyPy', 'trunk', '63378'), self.save_platform): ("PyPy", "2.5.2", "trunk", "63378", ('63378', 'Mar 26 2009'), "") } for (version_tag, subversion, sys_platform), info in \ sys_versions.items(): sys.version = version_tag if subversion is None: if hasattr(sys, "_mercurial"): del sys._mercurial else: sys._mercurial = subversion if sys_platform is not None: sys.platform = sys_platform self.assertEqual(platform.python_implementation(), info[0]) self.assertEqual(platform.python_version(), info[1]) self.assertEqual(platform.python_branch(), info[2]) self.assertEqual(platform.python_revision(), info[3]) self.assertEqual(platform.python_build(), info[4]) self.assertEqual(platform.python_compiler(), info[5])
def get_platform_info() -> dict: """Recovers information about the current platform's operating system, its processor and its Python interpreter. It uses the module platform to obtain that information. The returned dictionary contains the following structure: 1. 'platform': A summary of the current platform. 2. 'node': The name of the host machine. 3. 'os': Information about the operating system. It contains the following keys: 3.1. 'system': The general name of the operating system. Examples: "Linux", "Windows". 3.2. 'release': The general number of release of the operating system. 3.3. 'version': The specific release version of the operating system. 4. 'hardware': Information about the processor. It contains the following keys: 4.1. 'machine': The general architecture of the processor. 4.2. 'processor: The name of the processor. Not all platforms provide it. In some cases it may contain the same value as 'machine'. 5. 'python': Information about the Python interpreter. It contains the following keys: 5.1. 'build': A tuple of two strings; the first one is the build's number and the second one is its date. 5.2. 'compiler': The compiler used to build the interpreter. 5.3. 'implementation': The specific implementation of the interpreter. Example: "CPython". 5.4. 'version': The used version of the language. Returns ------- dict A dictionary containing the structure previously described. """ os_info = {} os_info['system'] = platform.system() os_info['release'] = platform.release() os_info['version'] = platform.version() hw_info = {} hw_info['machine'] = platform.machine() hw_info['processor'] = platform.processor() py_info = {} py_info['build'] = platform.python_build() py_info['compiler'] = platform.python_compiler() py_info['implementation'] = platform.python_implementation() py_info['version'] = platform.python_version() info = {} info['platform'] = platform.platform() info['node'] = platform.node() info['os'] = os_info info['hardware'] = hw_info info['python'] = py_info return info
"BLPAPI_ROOT (or BLPAPI_INCDIR/BLPAPI_LIBDIR) " + \ "environment variable isn't defined" is64bit = plat.architecture()[0] == '64bit' if is64bit: blpapiLibraryName = 'blpapi3_64' else: blpapiLibraryName = 'blpapi3_32' extraLinkArgs = [] if platform == 'windows': extraLinkArgs = ['/MANIFEST'] # Handle the very frequent case when user need to use Visual C++ 2010 # with Python that wants to use Visual C++ 2008. if plat.python_compiler().startswith('MSC v.1500'): if (not 'VS90COMNTOOLS' in os.environ) and \ ('VS100COMNTOOLS' in os.environ): os.environ['VS90COMNTOOLS'] = os.environ['VS100COMNTOOLS'] blpapiLibraryPath = blpapiLibVar or os.path.join(blpapiRoot, lib_in_release()) blpapiIncludes = blpapiIncludesVar or os.path.join(blpapiRoot, 'include') blpapi_wrap = Extension('blpapi._internals', sources=['blpapi/internals_wrap.c'], include_dirs=[blpapiIncludes], library_dirs=[blpapiLibraryPath], libraries=[blpapiLibraryName], extra_link_args=extraLinkArgs) versionhelper_wrap = Extension('blpapi._versionhelper',
verinfodata = re.sub( "__build_time_utc__ \= \{.*\}\;", '__build_time_utc__ = {"timestamp": ' + str(utccurtimestamp) + ', "year": ' + str(utccurtimetuple[0]) + ', "month": ' + str(utccurtimetuple[1]) + ', "day": ' + str(utccurtimetuple[2]) + ', "hour": ' + str(utccurtimetuple[3]) + ', "minute": ' + str(utccurtimetuple[4]) + ', "second": ' + str(utccurtimetuple[5]) + '};', verinfodata) if (sys.version[0] == "2"): '''verinfodata = verinfodata.replace('__build_python_info__ = {"python_branch": None, "python_build": None, "python_compiler": None, "python_implementation": None, "python_revision": None, "python_version": None, "python_version_tuple": None, "release": None, "system": None, "uname": None, "machine": None, "node": None, "platform": None, "processor": None, "version": None, "java_ver": None, "win32_ver": None, "mac_ver": None, "linux_distribution": None, "libc_ver": None};', '__build_python_info__ = '+str({'python_branch': platform.python_branch(), 'python_build': platform.python_build(), 'python_compiler': platform.python_compiler(), 'python_implementation': platform.python_implementation(), 'python_revision': platform.python_revision(), 'python_version': platform.python_version(), 'python_version_tuple': platform.python_version_tuple(), 'release': platform.release(), 'system': platform.system(), 'uname': platform.uname(), 'machine': platform.machine(), 'node': platform.node(), 'platform': platform.platform(), 'processor': platform.processor(), 'architecture': platform.architecture(), 'version': platform.version(), 'java_ver': platform.java_ver(), 'win32_ver': platform.win32_ver(), 'mac_ver': platform.mac_ver(), 'linux_distribution': platform.linux_distribution(), 'libc_ver': platform.libc_ver()})+';');''' verinfodata = re.sub( "__build_python_info__ \= \{.*\}\;", '__build_python_info__ = ' + str({ 'python_branch': platform.python_branch(), 'python_build': platform.python_build(), 'python_compiler': platform.python_compiler(), 'python_implementation': platform.python_implementation(), 'python_revision': platform.python_revision(), 'python_version': platform.python_version(), 'python_version_tuple': platform.python_version_tuple(), 'release': platform.release(), 'system': platform.system(), 'uname': platform.uname(), 'machine': platform.machine(), 'node': platform.node(), 'platform': platform.platform(), 'processor': platform.processor(), 'architecture': platform.architecture(), 'version': platform.version(), 'java_ver': platform.java_ver(), 'win32_ver': platform.win32_ver(),
def print_sysinfo(): print('\nPython version : {}'.format(platform.python_version())) print('compiler : {}'.format(platform.python_compiler())) print('\nsystem : {}'.format(platform.system())) print('release : {}'.format(platform.release())) print('machine : {}'.format(platform.machine())) print('processor : {}'.format(platform.processor())) print('CPU count : {}'.format(mp.cpu_count())) print('interpreter: {}'.format(platform.architecture()[0])) print('\n\n') # def set_ax_plot(ax, models=['base_model'], models_aka=['base_model'], y_name = 'val_dice', x_name = 'epochs', mode='summary', niters=None): # x_title = x_name.title() # if 'val' in y_name: # y_title = y_name.split('_')[-1].title() # title = 'Validation History - %s (per %s)' % (y_title, x_title) # else: # y_title = y_name.title() # title = 'History - %s (per %s)' % (y_title, x_title) # ax.set_title(title, fontdict={'fontsize':15}) # for col, model in enumerate(models): # aka = models_aka[col] # hist_path = './%s/history/hist.json' % (model) # kfold = len(glob.glob(file_path_fold(hist_path,'*'))) # with open(file_path_fold(hist_path,kfold-1), 'r') as f: # history = json.load(f) # max_epoch = np.max([len(hist['loss']) for hist in history]) # if not niters == None: niter = niters[col] # else: niter = None # if 'epoch' in x_name: index = np.arange(1, max_epoch+1) # elif 'iter' in x_name: index = np.arange(1, max_epoch*niter+1, niter) # else: raise ValueError # value = np.zeros((len(history),max_epoch)) # for i, hist in enumerate(history): # value[i,:len(hist[y_name])] = hist[y_name] # if mode == 'summary': # ax.plot(index, np.mean(value, axis=0), 'C%s.-' % (col+1), label='%s-%s'% (aka, y_title)) # ax.fill_between(index, np.mean(value, axis=0)-np.std(value, axis=0), np.mean(value, axis=0)+np.std(value, axis=0), # color='C%s' % (col+1), alpha=0.2) # if 'accuracy' in y_name : # total epoch max per each fold # ax.plot(index[np.argmax(value, axis=1)], np.max(value, axis=1), 'C%s*' % (col+1), markersize=12) # for j, (x,y) in enumerate(zip(index[np.argmax(value, axis=1)], np.max(value, axis=1))): # ax.annotate(j+1, (x,y)) # if 'loss' in y_name : # total epoch min per each fold # ax.plot(index[np.argmax(value, axis=1)], np.min(value, axis=1), 'C%s*' % (col+1), markersize=12) # for j, (x,y) in enumerate(zip(index[np.argmin(value, axis=1)], np.min(value, axis=1))): # ax.annotate(j+1, (x,y)) # # ax.plot(index, np.max(value, axis=0), 'C%s.' % (col+1), alpha=0.3) # total fold max per epoch # # ax.plot(index, np.min(value, axis=0), 'C%s.' % (col+1), alpha=0.3) # total fold min per epoch # elif mode == 'all': # for j, v in enumerate(value): # if j == 0: ax.plot(index, v, 'C%s.-' % (col+1), label='%s-%s'% (aka, y_title), alpha=0.4) # else: ax.plot(index, v, 'C%s.-' % (col+1), alpha=0.4) # ax.set_xlabel(x_title) # ax.set_ylabel(y_title) # ax.legend(loc='lower right', fontsize='small') # def plot_history(models, models_aka, # history_types = ['validation','train'], y_names = ['dice','precision','recall'], x_name='epochs', # mode = 'summary', figsize=(20,20), niters=None): # fig, axes = plt.subplots(len(y_names), len(history_types), figsize=figsize) # if len(y_names) == 1: axes = np.expand_dims(axes, 0) # if len(history_types) == 1: axes = np.expand_dims(axes, -1) # for j in range(len(history_types)): # for i, y_name in enumerate(y_names): # if 'val' in history_types[j]: set_ax_plot(axes[i,j], models, models_aka, 'val_%s' % y_name, x_name, mode, niters) # else: set_ax_plot(axes[i,j], models, models_aka, y_name, x_name, mode, niters) # fig.tight_layout() # return fig # class TensorBoardWrapper(TensorBoard): # ''' # Sets the self.validation_data property for use with TensorBoard callback. # Image Summary with multi-modal medical 3D volumes: # Thumbnail of nrow x ncol 2D images (of one person) # nrow: number of slice (z-axis) # ncol: # input images: number of modals # bottleneck images : number of filters # output images: 2 (GT, predict) # TODO: fix one person as reference.. # ''' # def __init__(self, validation_data, write_weights_histogram = True, write_weights_images=False, # tb_data_steps=1, **kwargs): # super(TensorBoardWrapper, self).__init__(**kwargs) # self.write_weights_histogram = write_weights_histogram # self.write_weights_images = write_weights_images # self.tb_data_steps = tb_data_steps # self.validation_data = validation_data # if self.embeddings_data is None and self.validation_data: # self.embeddings_data = self.validation_data # def set_model(self, model): # self.model = model # if k.backend() == 'tensorflow': # self.sess = k.get_session() # if self.histogram_freq and self.merged is None: # for layer in self.model.layers: # for weight in layer.weights: # mapped_weight_name = 'weight_%s' % weight.name.replace(':', '_') # # histogram # if self.write_weights_histogram: tf.summary.histogram(mapped_weight_name, weight) # # gradient histogram # if self.write_grads: # grads = model.optimizer.get_gradients(model.total_loss, # weight) # def is_indexed_slices(grad): # return type(grad).__name__ == 'IndexedSlices' # grads = [ # grad.values if is_indexed_slices(grad) else grad # for grad in grads] # tf.summary.histogram('{}_grad'.format(mapped_weight_name), grads) # if self.write_weights_images: # w_img = tf.squeeze(weight) # shape = k.int_shape(w_img) # if len(shape) == 2: # dense layer kernel case # if shape[0] > shape[1]: # w_img = tf.transpose(w_img) # shape = k.int_shape(w_img) # w_img = tf.reshape(w_img, [1, # shape[0], # shape[1], # 1]) # elif len(shape) == 3: # 1d convnet case # if k.image_data_format() == 'channels_last': # # switch to channels_first to display # # every kernel as a separate image # w_img = tf.transpose(w_img, perm=[2, 0, 1]) # shape = k.int_shape(w_img) # w_img = tf.reshape(w_img, [shape[0], # shape[1], # shape[2], # 1]) # elif len(shape) == 4: # conv2D # # input_dim * output_dim, width, hieght # w_img = tf.transpose(w_img, perm=[2, 3, 0, 1]) # shape = k.int_shape(w_img) # w_img = tf.reshape(w_img, [shape[0]*shape[1], # shape[2], # shape[3], # 1]) # elif len(shape) == 5: # conv3D # # input_dim * output_dim*depth, width, hieght # w_img = tf.transpose(w_img, perm=[3, 4, 0, 1, 2]) # shape = k.int_shape(w_img) # w_img = tf.reshape(w_img, [shape[0]*shape[1]*shape[2], # shape[3], # shape[4], # 1]) # elif len(shape) == 1: # bias case # w_img = tf.reshape(w_img, [1, # shape[0], # 1, # 1]) # tf.summary.image(mapped_weight_name, w_img) # if hasattr(layer, 'output'): # if isinstance(layer.output, list): # for i, output in enumerate(layer.output): # tf.summary.histogram('{}_out_{}'.format(layer.name, i), output) # else: # tf.summary.histogram('{}_out'.format(layer.name), # layer.output) # ################################################################################# # # image summary # # if self.write_images: # # input_shape = [] # # input_shape[:] = self.img_shape[:] # # input_shape[-1] += 2 # # tot_pred_image = [] # # for i in range(self.batch_size): # # # input images, GT, prediction # # mri = model.inputs[0][i] # # gt = model.targets[0][i] # # pred = model.outputs[0][i] # # pred_image = self.tile_patches_medical(k.concatenate([mri, gt, pred], axis=-1), # # shape=input_shape, zcut=[10,6]) # output : [1,x*nrow, y*ncol, 1] # # pred_image = colorize(pred_image, cmap='inferno') # output : [x*nrow, y*ncol, 3] # # tot_pred_image.append(pred_image) # # tot_pred_image = k.stack(tot_pred_image) # output : [batch, x*nrow, y*ncol, 3] # # shape = k.int_shape(tot_pred_image) # # assert len(shape) == 4 and shape[-1] in [1, 3, 4] # # tf.summary.image('prediction', tot_pred_image, max_outputs=self.batch_size) # ################################################################################# # self.merged = tf.summary.merge_all() # ################################################################################# # # tensor graph & file write # if self.write_graph: # self.writer = tf.summary.FileWriter(self.log_dir, # self.sess.graph) # else: # self.writer = tf.summary.FileWriter(self.log_dir) # ################################################################################# # # embedding : TODO # if self.embeddings_freq: # embeddings_layer_names = self.embeddings_layer_names # if not embeddings_layer_names: # embeddings_layer_names = [layer.name for layer in self.model.layers # if type(layer).__name__ == 'Embedding'] # self.assign_embeddings = [] # embeddings_vars = {} # self.batch_id = batch_id = tf.placeholder(tf.int32) # self.step = step = tf.placeholder(tf.int32) # for layer in self.model.layers: # if layer.name in embeddings_layer_names: # embedding_input = self.model.get_layer(layer.name).output # embedding_size = int(np.prod(embedding_input.shape[1:])) # embedding_input = tf.reshape(embedding_input, # (step, embedding_size)) # shape = (self.embeddings_data[0].shape[0], embedding_size) # embedding = tf.Variable(tf.zeros(shape), # name=layer.name + '_embedding') # embeddings_vars[layer.name] = embedding # batch = tf.assign(embedding[batch_id:batch_id + step], # embedding_input) # self.assign_embeddings.append(batch) # self.saver = tf.train.Saver(list(embeddings_vars.values())) # embeddings_metadata = {} # if not isinstance(self.embeddings_metadata, str): # embeddings_metadata = self.embeddings_metadata # else: # embeddings_metadata = {layer_name: self.embeddings_metadata # for layer_name in embeddings_vars.keys()} # config = projector.ProjectorConfig() # for layer_name, tensor in embeddings_vars.items(): # embedding = config.embeddings.add() # embedding.tensor_name = tensor.name # if layer_name in embeddings_metadata: # embedding.metadata_path = embeddings_metadata[layer_name] # projector.visualize_embeddings(self.writer, config) # def on_epoch_end(self, epoch, logs=None): # logs = logs or {} # if not self.validation_data and self.histogram_freq: # raise ValueError("If printing histograms, validation_data must be " # "provided, and cannot be a generator.") # if self.embeddings_data is None and self.embeddings_freq: # raise ValueError("To visualize embeddings, embeddings_data must " # "be provided.") # if self.validation_data and self.histogram_freq: # if epoch % self.histogram_freq == 0: # TODO : last epoch.. # val_data = self.validation_data # if self.batch_size == None: # self.batch_size = val_data[0].shape[0] # tensors = (self.model.inputs + # self.model.targets + # self.model.sample_weights) # if self.model.uses_learning_phase: # tensors += [k.learning_phase()] # try: # for i in range(self.tb_data_steps): # x, y = val_data[i] # if self.model.uses_learning_phase: # batch_val = np.array([x, y, np.ones(self.batch_size, dtype=np.float32), 0.0]) # else: # batch_val = np.array([x, y, np.ones(self.batch_size, dtype=np.float32)]) # assert len(batch_val) == len(tensors) # feed_dict = dict(zip(tensors, batch_val)) # result = self.sess.run([self.merged], feed_dict=feed_dict) # summary_str = result[0] # self.writer.add_summary(summary_str, epoch) # except: # val_size = val_data[0].shape[0] # i = 0 # while i < val_size: # step = min(self.batch_size, val_size - i) # if self.model.uses_learning_phase: # # do not slice the learning phase # batch_val = [x[i:i + step] for x in val_data[:-1]] # batch_val.append(val_data[-1]) # else: # batch_val = [x[i:i + step] for x in val_data] # assert len(batch_val) == len(tensors) # feed_dict = dict(zip(tensors, batch_val)) # result = self.sess.run([self.merged], feed_dict=feed_dict) # summary_str = result[0] # self.writer.add_summary(summary_str, epoch) # i += self.batch_size # if self.embeddings_freq and self.embeddings_data is not None: # if epoch % self.embeddings_freq == 0: ## TODO : Last epoch.. # embeddings_data = self.embeddings_data # for i in range(self.tb_data_steps): # if type(self.model.input) == list: # feed_dict = {model_input: embeddings_data[i][idx] # for idx, model_input in enumerate(self.model.input)} # else: # feed_dict = {self.model.input: embeddings_data[i]} # feed_dict.update({self.batch_id: i, self.step: self.batch_size}) # if self.model.uses_learning_phase: # feed_dict[k.learning_phase()] = False # self.sess.run(self.assign_embeddings, feed_dict=feed_dict) # self.saver.save(self.sess, # os.path.join(self.log_dir, 'keras_embedding.ckpt'), # epoch) # for name, value in logs.items(): # if name in ['batch', 'size']: # continue # summary = tf.Summary() # summary_value = summary.value.add() # summary_value.simple_value = value.item() # summary_value.tag = name # self.writer.add_summary(summary, epoch) # self.writer.flush()
def get_sys_info(): # delay these imports until now as they are only needed in this # function which then exits. import platform import json import multiprocessing from numba import config from numba import cuda as cu from numba.cuda import cudadrv from numba.cuda.cudadrv.driver import driver as cudriver from numba import roc from numba.roc.hlc import hlc, libhlc import textwrap as tw import ctypes as ct import llvmlite.binding as llvmbind import locale from datetime import datetime from itertools import chain from subprocess import check_output, CalledProcessError try: fmt = "%-45s : %-s" print("-" * 80) print("__Time Stamp__") print(datetime.utcnow()) print("") print("__Hardware Information__") system_name = platform.system() print(fmt % ("Machine", platform.machine())) print(fmt % ("CPU Name", llvmbind.get_host_cpu_name())) if system_name == 'Linux': strmatch = 'Cpus_allowed' try: loc = '/proc/self/status' with open(loc, 'rt') as f: proc_stat = f.read().splitlines() for x in proc_stat: if x.startswith(strmatch): if x.startswith('%s:' % strmatch): hexnum = '0x%s' % x.split(':')[1].strip() acc_cpus = int(hexnum, 16) _n = str(bin(acc_cpus).count('1')) print(fmt % ("Number of accessible CPU cores", _n)) elif x.startswith('%s_list:' % strmatch): _a = x.split(':')[1].strip() print(fmt % ("Listed accessible CPUs cores", _a)) except Exception: print(fmt % ("CPU count", multiprocessing.cpu_count())) # See if CFS is in place # https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt try: def scrape_lines(loc): with open(loc, 'rt') as f: return f.read().splitlines() loc = '/sys/fs/cgroup/cpuacct/cpu.cfs_period_us' cfs_period = int(scrape_lines(loc)[0]) loc = '/sys/fs/cgroup/cpuacct/cpu.cfs_quota_us' cfs_quota = int(scrape_lines(loc)[0]) if cfs_quota == -1: print(fmt % ("CFS restrictions", "None")) else: runtime_amount = float(cfs_quota)/float(cfs_period) print(fmt % ("CFS restrictions (CPUs worth of runtime)", runtime_amount)) except Exception: print(fmt % ("CFS restrictions", 'Information not available')) else: print(fmt % ("CPU count", multiprocessing.cpu_count())) try: featuremap = llvmbind.get_host_cpu_features() except RuntimeError: print(fmt % ("CPU Features", "NA")) else: features = sorted([key for key, value in featuremap.items() if value]) cpu_feat = tw.fill(' '.join(features), 80) print(fmt % ("CPU Features", "")) print(cpu_feat) print("") print("__OS Information__") print(fmt % ("Platform", platform.platform(aliased=True))) print(fmt % ("Release", platform.release())) print(fmt % ("System Name", system_name)) print(fmt % ("Version", platform.version())) try: if system_name == 'Linux': info = platform.linux_distribution() elif system_name == 'Windows': info = platform.win32_ver() elif system_name == 'Darwin': info = platform.mac_ver() else: raise RuntimeError("Unknown system.") buf = ''.join([x if x != '' else ' ' for x in list(chain.from_iterable(info))]) print(fmt % ("OS specific info", buf)) if system_name == 'Linux': print(fmt % ("glibc info", ' '.join(platform.libc_ver()))) except: print("Error: System name incorrectly identified or unknown.") print("") print("__Python Information__") print(fmt % ("Python Compiler", platform.python_compiler())) print( fmt % ("Python Implementation", platform.python_implementation())) print(fmt % ("Python Version", platform.python_version())) lcl = [] try: for x in locale.getdefaultlocale(): if x is not None: lcl.append(x) except Exception as e: lcl.append(str(e)) print(fmt % ("Python Locale ", ' '.join(lcl))) print("") print("__LLVM information__") print( fmt % ("LLVM version", '.'.join( [str(k) for k in llvmbind.llvm_version_info]))) print("") print("__CUDA Information__") # Look for GPUs try: cu.list_devices()[0] # will a device initialise? except Exception as e: msg_not_found = "CUDA driver library cannot be found" msg_disabled_by_user = "******" msg_end = " or no CUDA enabled devices are present." msg_generic_problem = "Error: CUDA device intialisation problem." msg = getattr(e, 'msg', None) if msg is not None: if msg_not_found in msg: err_msg = msg_not_found + msg_end elif msg_disabled_by_user in msg: err_msg = msg_disabled_by_user + msg_end else: err_msg = msg_generic_problem + " Message:" + msg else: err_msg = msg_generic_problem + " " + str(e) # Best effort error report print("%s\nError class: %s" % (err_msg, str(type(e)))) else: try: cu.detect() dv = ct.c_int(0) cudriver.cuDriverGetVersion(ct.byref(dv)) print(fmt % ("CUDA driver version", dv.value)) print("CUDA libraries:") cudadrv.libs.test(sys.platform, print_paths=False) except: print( "Error: Probing CUDA failed (device and driver present, runtime problem?)\n") print("") print("__ROC Information__") roc_is_available = roc.is_available() print(fmt % ("ROC available", roc_is_available)) toolchains = [] try: libhlc.HLC() toolchains.append('librocmlite library') except: pass try: cmd = hlc.CmdLine().check_tooling() toolchains.append('ROC command line tools') except: pass # if no ROC try and report why if not roc_is_available: from numba.roc.hsadrv.driver import hsa try: hsa.is_available except Exception as e: msg = str(e) else: msg = 'No ROC toolchains found.' print(fmt % ("Error initialising ROC due to", msg)) if toolchains: print(fmt % ("Available Toolchains", ', '.join(toolchains))) try: # ROC might not be available due to lack of tool chain, but HSA # agents may be listed from numba.roc.hsadrv.driver import hsa, dgpu_count decode = lambda x: x.decode('utf-8') if isinstance(x, bytes) else x print("\nFound %s HSA Agents:" % len(hsa.agents)) for i, agent in enumerate(hsa.agents): print('Agent id : %s' % i) print(' vendor: %s' % decode(agent.vendor_name)) print(' name: %s' % decode(agent.name)) print(' type: %s' % agent.device) print("") _dgpus = [] for a in hsa.agents: if a.is_component and a.device == 'GPU': _dgpus.append(decode(a.name)) print(fmt % ("Found %s discrete GPU(s)" % dgpu_count(), \ ', '.join(_dgpus))) except Exception as e: print("No HSA Agents found, encountered exception when searching:") print(e) print("") print("__SVML Information__") # replicate some SVML detection logic from numba.__init__ here. # if SVML load fails in numba.__init__ the splitting of the logic # here will help diagnosis of the underlying issue have_svml_library = True try: if sys.platform.startswith('linux'): llvmbind.load_library_permanently("libsvml.so") elif sys.platform.startswith('darwin'): llvmbind.load_library_permanently("libsvml.dylib") elif sys.platform.startswith('win'): llvmbind.load_library_permanently("svml_dispmd") else: have_svml_library = False except: have_svml_library = False func = getattr(llvmbind.targets, "has_svml", None) llvm_svml_patched = func() if func is not None else False svml_operational = (config.USING_SVML and llvm_svml_patched \ and have_svml_library) print(fmt % ("SVML state, config.USING_SVML", config.USING_SVML)) print(fmt % ("SVML library found and loaded", have_svml_library)) print(fmt % ("llvmlite using SVML patched LLVM", llvm_svml_patched)) print(fmt % ("SVML operational", svml_operational)) # Check which threading backends are available. print("") print("__Threading Layer Information__") def parse_error(e, backend): # parses a linux based error message, this is to provide feedback # and hide user paths etc try: path, problem, symbol = [x.strip() for x in e.msg.split(':')] extn_dso = os.path.split(path)[1] if backend in extn_dso: return "%s: %s" % (problem, symbol) except Exception: pass return "Unknown import problem." try: from numba.npyufunc import tbbpool print(fmt % ("TBB Threading layer available", True)) except ImportError as e: # might be a missing symbol due to e.g. tbb libraries missing print(fmt % ("TBB Threading layer available", False)) print(fmt % ("+--> Disabled due to", parse_error(e, 'tbbpool'))) try: from numba.npyufunc import omppool print(fmt % ("OpenMP Threading layer available", True)) except ImportError as e: print(fmt % ("OpenMP Threading layer available", False)) print(fmt % ("+--> Disabled due to", parse_error(e, 'omppool'))) try: from numba.npyufunc import workqueue print(fmt % ("Workqueue Threading layer available", True)) except ImportError as e: print(fmt % ("Workqueue Threading layer available", False)) print(fmt % ("+--> Disabled due to", parse_error(e, 'workqueue'))) # look for numba env vars that are set print("") print("__Numba Environment Variable Information__") _envvar_found = False for k, v in os.environ.items(): if k.startswith('NUMBA_'): print(fmt % (k, v)) _envvar_found = True if not _envvar_found: print("None set.") # Look for conda and conda information print("") print("__Conda Information__") cmd = ["conda", "info", "--json"] try: conda_out = check_output(cmd) except Exception as e: print( "Conda not present/not working.\nError was %s\n" % e) else: data = ''.join(conda_out.decode("utf-8").splitlines()) jsond = json.loads(data) keys = ['conda_build_version', 'conda_env_version', 'platform', 'python_version', 'root_writable'] for k in keys: try: print(fmt % (k, jsond[k])) except KeyError: pass # get info about current environment cmd = ["conda", "list"] try: conda_out = check_output(cmd) except CalledProcessError as e: print("Error: Conda command failed. Error was %s\n" % e.output) else: print("") print("__Current Conda Env__") data = conda_out.decode("utf-8").splitlines() for k in data: if k[0] != '#': # don't show where the env is, personal data print(k) print("-" * 80) except Exception as e: print("Error: The system reporting tool has failed unexpectedly.") print("Exception was:") print(e) finally: print( "%s" % "If requested, please copy and paste the information between\n" "the dashed (----) lines, or from a given specific section as\n" "appropriate.\n\n" "=============================================================\n" "IMPORTANT: Please ensure that you are happy with sharing the\n" "contents of the information present, any information that you\n" "wish to keep private you should remove before sharing.\n" "=============================================================\n")
def finalize_options(self): _build.finalize_options(self) compiler = new_compiler(compiler=self.compiler, verbose=self.verbose) customize_compiler(compiler) disabled_libraries = [] # Section for custom limits imposed on the SIMD instruction levels based # on the installed compiler plat_compiler = platform.python_compiler() if plat_compiler.lower().startswith('gcc'): # Check the installed gcc version, as versions older than 7.0 claim to # support avx512 but are missing some intrinsics that FastNoiseSIMD calls output = subprocess.check_output('gcc --version', shell=True) gcc_version = tuple([ int(x) for x in re.findall(b'\d+(?:\.\d+)+', output)[0].split(b'.') ]) if gcc_version < (7, 2): # Disable AVX512 disabled_libraries.append('avx512') if gcc_version < (4, 7): # Disable AVX2 disabled_libraries.append('avx2') elif plat_compiler.lower().startswith('msc'): # No versions of Windows Python support AVX512 yet # MSVC++ 14.1 _MSC_VER == 1911 (Visual Studio 2017) # MSVC++ 14.1 _MSC_VER == 1910 (Visual Studio 2017) # Python 3.5/3.6: MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015) # Python 3.4: MSVC++ 10.0 _MSC_VER == 1600 (Visual Studio 2010) # Python 2.7: MSVC++ 9.0 _MSC_VER == 1500 (Visual Studio 2008) # Here we just assume the user has the platform compiler msc_version = int( re.findall('v\.\d+', plat_compiler)[0].lstrip('v.')) # print('FOUND MSVC VERSION: ', msc_version) # Still not working with MSVC2017 yet with 1915 and Python 3.7, it # cannot find the function `_mm512_floor_ps` if msc_version < 1916: disabled_libraries.append('avx512') if msc_version < 1900: disabled_libraries.append('avx2') # End of SIMD limits for name, lib in self.distribution.libraries: val = getattr(self, 'with_' + name) if val not in ('auto', 'yes', 'no'): raise DistutilsOptionError('with_%s flag must be auto, yes, ' 'or no, not "%s".' % (name, val)) if val == 'no': disabled_libraries.append(name) continue if not self.compiler_has_flags(compiler, name, lib['cflags']): if val == 'yes': # Explicitly required but not available. raise CCompilerError('%s is not supported by your ' 'compiler.' % (name, )) disabled_libraries.append(name) use_fma = False if (self.with_fma != 'no' and ('avx512' not in disabled_libraries or 'avx2' not in disabled_libraries)): if fma_flags is None: # No flags required. use_fma = True elif self.compiler_has_flags(compiler, 'fma', fma_flags): use_fma = True avx512['cflags'] += fma_flags avx2['cflags'] += fma_flags elif self.with_fma == 'yes': # Explicitly required but not available. raise CCompilerError('FMA is not supported by your compiler.') self.distribution.libraries = [ lib for lib in self.distribution.libraries if lib[0] not in disabled_libraries ] with open('pyfastnoisesimd/fastnoisesimd/x86_flags.h', 'wb') as fh: fh.write(b'// This file is generated by setup.py, ' b'do not edit it by hand\n') for name, lib in self.distribution.libraries: fh.write(b'#define FN_COMPILE_%b\n' % (name.upper().encode('ascii', ))) if use_fma: fh.write(b'#define FN_USE_FMA\n')
def check_installation(): """Utility function to check package installation. """ import pkg_resources import os import sys import platform import subprocess log = ui.FancyPrinter() # Get system information log.line('System information') log.data(field='System', value=platform.system()) log.data(field='Release', value=platform.release()) log.data(field='Version', value=platform.version()) log.data(field='Processor', value=platform.processor()) log.line() # Get Python installation information log.line('Python information') log.data(field='Version', value=sys.version) log.data(field='Compiler', value=platform.python_compiler()) log.data(field='Implementation', value=platform.python_implementation()) log.line() # Get package information log.line('Package information') log.data(field='Name', value=__name__) log.data(field='Version', value=__version__) log.line() package = pkg_resources.require('dcase_util')[0] # Get core requirements core_requirements = package.requires() # Load requirements.txt requirements_filename = os.path.join(package.location, 'requirements.txt') with open(requirements_filename) as fp: requirements_file = fp.read() # Get all requirements all_requirements = [] for r in pkg_resources.parse_requirements(requirements_file): if r.marker: raise ValueError("environment markers are not supported, in '%s'" % r) all_requirements.append(r) processed = [] log.line('Core requirements') log.row('Package', 'Required', 'Installed', 'Status', widths=[25, 15, 15, 15]) log.row_sep() for requirement in core_requirements: if requirement.key not in processed: log.row( requirement.key, ''.join(requirement.specs[0]), pkg_resources.get_distribution(requirement.key).version, 'OK' if requirement.__contains__( pkg_resources.get_distribution( requirement.key)) else 'CHECK') processed.append(requirement.key) log.line() log.line('Extra requirements') log.row('Package', 'Required', 'Installed', 'Status', widths=[25, 15, 15, 15]) log.row_sep() for requirement in all_requirements: if requirement.key not in processed: log.row( requirement.key, ''.join(requirement.specs[0]), pkg_resources.get_distribution(requirement.key).version, 'OK' if requirement.__contains__( pkg_resources.get_distribution( requirement.key)) else 'CHECK') processed.append(requirement.key) log.line() # Get system level requirements log.line('System') ffmpeg_info = subprocess.check_output(['ffmpeg', '-version']).decode('utf-8') log.data(field='FFMPEG', value=ffmpeg_info)
import platform print("COMPILER :", platform.python_compiler()) print("SYSTEM :", platform.system()) print("PROCESSOR :", platform.processor()) print("ARCHITECTURE :", platform.architecture()) print("MACHINE :", platform.machine()) print("JAVA VERSION :", platform.java_ver()) print("PYTHON VER :", platform.python_version()) print("SYSTEM VER :", platform._sys_version())
def get_sysinfo(): # Gather the information that shouldn't raise exceptions sys_info = { _start: datetime.now(), _start_utc: datetime.utcnow(), _machine: platform.machine(), _cpu_name: llvmbind.get_host_cpu_name(), _cpu_count: multiprocessing.cpu_count(), _platform_name: platform.platform(aliased=True), _platform_release: platform.release(), _os_name: platform.system(), _os_version: platform.version(), _python_comp: platform.python_compiler(), _python_impl: platform.python_implementation(), _python_version: platform.python_version(), _numba_env_vars: {k: v for (k, v) in os.environ.items() if k.startswith('NUMBA_')}, _llvm_version: '.'.join(str(i) for i in llvmbind.llvm_version_info), _roc_available: roc.is_available(), _psutil: _psutil_import, } # CPU features try: feature_map = llvmbind.get_host_cpu_features() except RuntimeError as e: _error_log.append(f'Error (CPU features): {e}') else: features = sorted([key for key, value in feature_map.items() if value]) sys_info[_cpu_features] = ' '.join(features) # Python locale # On MacOSX, getdefaultlocale can raise. Check again if Py > 3.7.5 try: # If $LANG is unset, getdefaultlocale() can return (None, None), make # sure we can encode this as strings by casting explicitly. sys_info[_python_locale] = '.'.join([str(i) for i in locale.getdefaultlocale()]) except Exception as e: _error_log.append(f'Error (locale): {e}') # CUDA information try: cu.list_devices()[0] # will a device initialise? except Exception as e: sys_info[_cu_dev_init] = False msg_not_found = "CUDA driver library cannot be found" msg_disabled_by_user = "******" msg_end = " or no CUDA enabled devices are present." msg_generic_problem = "CUDA device intialisation problem." msg = getattr(e, 'msg', None) if msg is not None: if msg_not_found in msg: err_msg = msg_not_found + msg_end elif msg_disabled_by_user in msg: err_msg = msg_disabled_by_user + msg_end else: err_msg = msg_generic_problem + " Message:" + msg else: err_msg = msg_generic_problem + " " + str(e) # Best effort error report _warning_log.append("Warning (cuda): %s\nException class: %s" % (err_msg, str(type(e)))) else: try: sys_info[_cu_dev_init] = True output = StringIO() with redirect_stdout(output): cu.detect() sys_info[_cu_detect_out] = output.getvalue() output.close() dv = ctypes.c_int(0) cudriver.cuDriverGetVersion(ctypes.byref(dv)) sys_info[_cu_drv_ver] = dv.value output = StringIO() with redirect_stdout(output): cudadrv.libs.test(sys.platform, print_paths=False) sys_info[_cu_lib_test] = output.getvalue() output.close() except Exception as e: _warning_log.append( "Warning (cuda): Probing CUDA failed " "(device and driver present, runtime problem?)\n" f"(cuda) {type(e)}: {e}") # ROC information # If no ROC try and report why if not sys_info[_roc_available]: from numba.roc.hsadrv.driver import hsa try: hsa.is_available except Exception as e: msg = str(e) else: msg = 'No ROC toolchains found.' _warning_log.append(f"Warning (roc): Error initialising ROC: {msg}") toolchains = [] try: libhlc.HLC() toolchains.append('librocmlite library') except Exception: pass try: cmd = hlc.CmdLine().check_tooling() toolchains.append('ROC command line tools') except Exception: pass sys_info[_roc_toolchains] = toolchains try: # ROC might not be available due to lack of tool chain, but HSA # agents may be listed from numba.roc.hsadrv.driver import hsa, dgpu_count def decode(x): return x.decode('utf-8') if isinstance(x, bytes) else x sys_info[_hsa_agents_count] = len(hsa.agents) agents = [] for i, agent in enumerate(hsa.agents): agents.append({ 'Agent id': i, 'Vendor': decode(agent.vendor_name), 'Name': decode(agent.name), 'Type': agent.device, }) sys_info[_hsa_agents] = agents _dgpus = [] for a in hsa.agents: if a.is_component and a.device == 'GPU': _dgpus.append(decode(a.name)) sys_info[_hsa_gpus_count] = dgpu_count() sys_info[_hsa_gpus] = ', '.join(_dgpus) except Exception as e: _warning_log.append( "Warning (roc): No HSA Agents found, " f"encountered exception when searching: {e}") # SVML information # Replicate some SVML detection logic from numba.__init__ here. # If SVML load fails in numba.__init__ the splitting of the logic # here will help diagnosing the underlying issue. svml_lib_loaded = True try: if sys.platform.startswith('linux'): llvmbind.load_library_permanently("libsvml.so") elif sys.platform.startswith('darwin'): llvmbind.load_library_permanently("libsvml.dylib") elif sys.platform.startswith('win'): llvmbind.load_library_permanently("svml_dispmd") else: svml_lib_loaded = False except Exception: svml_lib_loaded = False func = getattr(llvmbind.targets, "has_svml", None) sys_info[_llvm_svml_patched] = func() if func else False sys_info[_svml_state] = config.USING_SVML sys_info[_svml_loaded] = svml_lib_loaded sys_info[_svml_operational] = all(( sys_info[_svml_state], sys_info[_svml_loaded], sys_info[_llvm_svml_patched], )) # Check which threading backends are available. def parse_error(e, backend): # parses a linux based error message, this is to provide feedback # and hide user paths etc try: path, problem, symbol = [x.strip() for x in e.msg.split(':')] extn_dso = os.path.split(path)[1] if backend in extn_dso: return "%s: %s" % (problem, symbol) except Exception: pass return "Unknown import problem." try: from numba.np.ufunc import tbbpool # NOQA sys_info[_tbb_thread] = True except ImportError as e: # might be a missing symbol due to e.g. tbb libraries missing sys_info[_tbb_thread] = False sys_info[_tbb_error] = parse_error(e, 'tbbpool') try: from numba.np.ufunc import omppool sys_info[_openmp_thread] = True sys_info[_openmp_vendor] = omppool.openmp_vendor except ImportError as e: sys_info[_openmp_thread] = False sys_info[_openmp_error] = parse_error(e, 'omppool') try: from numba.np.ufunc import workqueue # NOQA sys_info[_wkq_thread] = True except ImportError as e: sys_info[_wkq_thread] = True sys_info[_wkq_error] = parse_error(e, 'workqueue') # Look for conda and installed packages information cmd = ('conda', 'info', '--json') try: conda_out = check_output(cmd) except Exception as e: _warning_log.append(f'Warning: Conda not available.\n Error was {e}\n') # Conda is not available, try pip list to list installed packages cmd = (sys.executable, '-m', 'pip', 'list') try: reqs = check_output(cmd) except Exception as e: _error_log.append(f'Error (pip): {e}') else: sys_info[_inst_pkg] = reqs.decode().splitlines() else: jsond = json.loads(conda_out.decode()) keys = { 'conda_build_version': _conda_build_ver, 'conda_env_version': _conda_env_ver, 'platform': _conda_platform, 'python_version': _conda_python_ver, 'root_writable': _conda_root_writable, } for conda_k, sysinfo_k in keys.items(): sys_info[sysinfo_k] = jsond.get(conda_k, 'N/A') # Get info about packages in current environment cmd = ('conda', 'list') try: conda_out = check_output(cmd) except CalledProcessError as e: _error_log.append(f'Error (conda): {e}') else: data = conda_out.decode().splitlines() sys_info[_inst_pkg] = [l for l in data if not l.startswith('#')] sys_info.update(get_os_spec_info(sys_info[_os_name])) sys_info[_errors] = _error_log sys_info[_warnings] = _warning_log sys_info[_runtime] = (datetime.now() - sys_info[_start]).total_seconds() return sys_info
def configuration(parent_package="", top_path=None): from numpy.distutils.misc_util import Configuration, dot_join from numpy.distutils.system_info import get_info config = Configuration("core", parent_package, top_path) local_dir = config.local_path codegen_dir = join(local_dir, "code_generators") if is_released(config): warnings.simplefilter("error", MismatchCAPIWarning) # Check whether we have a mismatch between the set C API VERSION and the # actual C API VERSION check_api_version(C_API_VERSION, codegen_dir) generate_umath_py = join(codegen_dir, "generate_umath.py") n = dot_join(config.name, "generate_umath") generate_umath = npy_load_module("_".join(n.split(".")), generate_umath_py, (".py", "U", 1)) header_dir = "include/numpy" # this is relative to config.path_in_package cocache = CallOnceOnly() def generate_config_h(ext, build_dir): target = join(build_dir, header_dir, "config.h") d = os.path.dirname(target) if not os.path.exists(d): os.makedirs(d) if newer(__file__, target): config_cmd = config.get_config_cmd() log.info("Generating %s", target) # Check sizeof moredefs, ignored = cocache.check_types(config_cmd, ext, build_dir) # Check math library and C99 math funcs availability mathlibs = check_mathlib(config_cmd) moredefs.append(("MATHLIB", ",".join(mathlibs))) check_math_capabilities(config_cmd, moredefs, mathlibs) moredefs.extend(cocache.check_ieee_macros(config_cmd)[0]) moredefs.extend(cocache.check_complex(config_cmd, mathlibs)[0]) # Signal check if is_npy_no_signal(): moredefs.append("__NPY_PRIVATE_NO_SIGNAL") # Windows checks if sys.platform == "win32" or os.name == "nt": win32_checks(moredefs) # C99 restrict keyword moredefs.append(("NPY_RESTRICT", config_cmd.check_restrict())) # Inline check inline = config_cmd.check_inline() # Use relaxed stride checking if NPY_RELAXED_STRIDES_CHECKING: moredefs.append(("NPY_RELAXED_STRIDES_CHECKING", 1)) # Use bogus stride debug aid when relaxed strides are enabled if NPY_RELAXED_STRIDES_DEBUG: moredefs.append(("NPY_RELAXED_STRIDES_DEBUG", 1)) # Get long double representation rep = check_long_double_representation(config_cmd) moredefs.append(("HAVE_LDOUBLE_%s" % rep, 1)) # Py3K check if sys.version_info[0] == 3: moredefs.append(("NPY_PY3K", 1)) # Generate the config.h file from moredefs with open(target, "w") as target_f: for d in moredefs: if isinstance(d, str): target_f.write("#define %s\n" % (d)) else: target_f.write("#define %s %s\n" % (d[0], d[1])) # define inline to our keyword, or nothing target_f.write("#ifndef __cplusplus\n") if inline == "inline": target_f.write("/* #undef inline */\n") else: target_f.write("#define inline %s\n" % inline) target_f.write("#endif\n") # add the guard to make sure config.h is never included directly, # but always through npy_config.h target_f.write( textwrap.dedent(""" #ifndef _NPY_NPY_CONFIG_H_ #error config.h should never be included directly, include npy_config.h instead #endif """)) print("File:", target) with open(target) as target_f: print(target_f.read()) print("EOF") else: mathlibs = [] with open(target) as target_f: for line in target_f: s = "#define MATHLIB" if line.startswith(s): value = line[len(s):].strip() if value: mathlibs.extend(value.split(",")) # Ugly: this can be called within a library and not an extension, # in which case there is no libraries attributes (and none is # needed). if hasattr(ext, "libraries"): ext.libraries.extend(mathlibs) incl_dir = os.path.dirname(target) if incl_dir not in config.numpy_include_dirs: config.numpy_include_dirs.append(incl_dir) return target def generate_numpyconfig_h(ext, build_dir): """Depends on config.h: generate_config_h has to be called before !""" # put common include directory in build_dir on search path # allows using code generation in headers headers config.add_include_dirs(join(build_dir, "src", "common")) config.add_include_dirs(join(build_dir, "src", "npymath")) target = join(build_dir, header_dir, "_numpyconfig.h") d = os.path.dirname(target) if not os.path.exists(d): os.makedirs(d) if newer(__file__, target): config_cmd = config.get_config_cmd() log.info("Generating %s", target) # Check sizeof ignored, moredefs = cocache.check_types(config_cmd, ext, build_dir) if is_npy_no_signal(): moredefs.append(("NPY_NO_SIGNAL", 1)) if is_npy_no_smp(): moredefs.append(("NPY_NO_SMP", 1)) else: moredefs.append(("NPY_NO_SMP", 0)) mathlibs = check_mathlib(config_cmd) moredefs.extend(cocache.check_ieee_macros(config_cmd)[1]) moredefs.extend(cocache.check_complex(config_cmd, mathlibs)[1]) if NPY_RELAXED_STRIDES_CHECKING: moredefs.append(("NPY_RELAXED_STRIDES_CHECKING", 1)) if NPY_RELAXED_STRIDES_DEBUG: moredefs.append(("NPY_RELAXED_STRIDES_DEBUG", 1)) # Check whether we can use inttypes (C99) formats if config_cmd.check_decl("PRIdPTR", headers=["inttypes.h"]): moredefs.append(("NPY_USE_C99_FORMATS", 1)) # visibility check hidden_visibility = visibility_define(config_cmd) moredefs.append(("NPY_VISIBILITY_HIDDEN", hidden_visibility)) # Add the C API/ABI versions moredefs.append(("NPY_ABI_VERSION", "0x%.8X" % C_ABI_VERSION)) moredefs.append(("NPY_API_VERSION", "0x%.8X" % C_API_VERSION)) # Add moredefs to header with open(target, "w") as target_f: for d in moredefs: if isinstance(d, str): target_f.write("#define %s\n" % (d)) else: target_f.write("#define %s %s\n" % (d[0], d[1])) # Define __STDC_FORMAT_MACROS target_f.write( textwrap.dedent(""" #ifndef __STDC_FORMAT_MACROS #define __STDC_FORMAT_MACROS 1 #endif """)) # Dump the numpyconfig.h header to stdout print("File: %s" % target) with open(target) as target_f: print(target_f.read()) print("EOF") config.add_data_files((header_dir, target)) return target def generate_api_func(module_name): def generate_api(ext, build_dir): script = join(codegen_dir, module_name + ".py") sys.path.insert(0, codegen_dir) try: m = __import__(module_name) log.info("executing %s", script) h_file, c_file, doc_file = m.generate_api( os.path.join(build_dir, header_dir)) finally: del sys.path[0] config.add_data_files((header_dir, h_file), (header_dir, doc_file)) return (h_file, ) return generate_api generate_numpy_api = generate_api_func("generate_numpy_api") generate_ufunc_api = generate_api_func("generate_ufunc_api") config.add_include_dirs(join(local_dir, "src", "common")) config.add_include_dirs(join(local_dir, "src")) config.add_include_dirs(join(local_dir)) config.add_data_dir("include/numpy") config.add_include_dirs(join("src", "npymath")) config.add_include_dirs(join("src", "multiarray")) config.add_include_dirs(join("src", "umath")) config.add_include_dirs(join("src", "npysort")) config.add_define_macros([ ("NPY_INTERNAL_BUILD", "1") ]) # this macro indicates that Numpy build is in process config.add_define_macros([("HAVE_NPY_CONFIG_H", "1")]) if sys.platform[:3] == "aix": config.add_define_macros([("_LARGE_FILES", None)]) else: config.add_define_macros([("_FILE_OFFSET_BITS", "64")]) config.add_define_macros([("_LARGEFILE_SOURCE", "1")]) config.add_define_macros([("_LARGEFILE64_SOURCE", "1")]) config.numpy_include_dirs.extend(config.paths("include")) deps = [ join("src", "npymath", "_signbit.c"), join("include", "numpy", "*object.h"), join(codegen_dir, "genapi.py"), ] ####################################################################### # dummy module # ####################################################################### # npymath needs the config.h and numpyconfig.h files to be generated, but # build_clib cannot handle generate_config_h and generate_numpyconfig_h # (don't ask). Because clib are generated before extensions, we have to # explicitly add an extension which has generate_config_h and # generate_numpyconfig_h as sources *before* adding npymath. config.add_extension( "_dummy", sources=[ join("src", "dummymodule.c"), generate_config_h, generate_numpyconfig_h, generate_numpy_api, ], ) ####################################################################### # npymath library # ####################################################################### subst_dict = dict([("sep", os.path.sep), ("pkgname", "numpy.core")]) def get_mathlib_info(*args): # Another ugly hack: the mathlib info is known once build_src is run, # but we cannot use add_installed_pkg_config here either, so we only # update the substitution dictionary during npymath build config_cmd = config.get_config_cmd() # Check that the toolchain works, to fail early if it doesn't # (avoid late errors with MATHLIB which are confusing if the # compiler does not work). st = config_cmd.try_link("int main(void) { return 0;}") if not st: raise RuntimeError( "Broken toolchain: cannot link a simple C program") mlibs = check_mathlib(config_cmd) posix_mlib = " ".join(["-l%s" % l for l in mlibs]) msvc_mlib = " ".join(["%s.lib" % l for l in mlibs]) subst_dict["posix_mathlib"] = posix_mlib subst_dict["msvc_mathlib"] = msvc_mlib npymath_sources = [ join("src", "npymath", "npy_math_internal.h.src"), join("src", "npymath", "npy_math.c"), join("src", "npymath", "ieee754.c.src"), join("src", "npymath", "npy_math_complex.c.src"), join("src", "npymath", "halffloat.c"), ] # Must be true for CRT compilers but not MinGW/cygwin. See gh-9977. # Intel and Clang also don't seem happy with /GL is_msvc = platform.platform().startswith( "Windows") and platform.python_compiler().startswith("MS") config.add_installed_library( "npymath", sources=npymath_sources + [get_mathlib_info], install_dir="lib", build_info={ "include_dirs": [], # empty list required for creating npy_math_internal.h "extra_compiler_args": (["/GL-"] if is_msvc else []), }, ) config.add_npy_pkg_config("npymath.ini.in", "lib/npy-pkg-config", subst_dict) config.add_npy_pkg_config("mlib.ini.in", "lib/npy-pkg-config", subst_dict) ####################################################################### # npysort library # ####################################################################### # This library is created for the build but it is not installed npysort_sources = [ join("src", "common", "npy_sort.h.src"), join("src", "npysort", "quicksort.c.src"), join("src", "npysort", "mergesort.c.src"), join("src", "npysort", "timsort.c.src"), join("src", "npysort", "heapsort.c.src"), join("src", "npysort", "radixsort.c.src"), join("src", "common", "npy_partition.h.src"), join("src", "npysort", "selection.c.src"), join("src", "common", "npy_binsearch.h.src"), join("src", "npysort", "binsearch.c.src"), ] config.add_library("npysort", sources=npysort_sources, include_dirs=[]) ####################################################################### # multiarray_tests module # ####################################################################### config.add_extension( "_multiarray_tests", sources=[ join("src", "multiarray", "_multiarray_tests.c.src"), join("src", "common", "mem_overlap.c"), ], depends=[ join("src", "common", "mem_overlap.h"), join("src", "common", "npy_extint128.h"), ], libraries=["npymath"], ) ####################################################################### # _multiarray_umath module - common part # ####################################################################### common_deps = [ join("src", "common", "array_assign.h"), join("src", "common", "binop_override.h"), join("src", "common", "cblasfuncs.h"), join("src", "common", "lowlevel_strided_loops.h"), join("src", "common", "mem_overlap.h"), join("src", "common", "npy_cblas.h"), join("src", "common", "npy_config.h"), join("src", "common", "npy_ctypes.h"), join("src", "common", "npy_extint128.h"), join("src", "common", "npy_import.h"), join("src", "common", "npy_longdouble.h"), join("src", "common", "templ_common.h.src"), join("src", "common", "ucsnarrow.h"), join("src", "common", "ufunc_override.h"), join("src", "common", "umathmodule.h"), join("src", "common", "numpyos.h"), ] common_src = [ join("src", "common", "array_assign.c"), join("src", "common", "mem_overlap.c"), join("src", "common", "npy_longdouble.c"), join("src", "common", "templ_common.h.src"), join("src", "common", "ucsnarrow.c"), join("src", "common", "ufunc_override.c"), join("src", "common", "numpyos.c"), ] blas_info = get_info("blas_opt", 0) if blas_info and ("HAVE_CBLAS", None) in blas_info.get( "define_macros", []): extra_info = blas_info # These files are also in MANIFEST.in so that they are always in # the source distribution independently of HAVE_CBLAS. common_src.extend([ join("src", "common", "cblasfuncs.c"), join("src", "common", "python_xerbla.c"), ]) if uses_accelerate_framework(blas_info): common_src.extend(get_sgemv_fix()) else: extra_info = {} ####################################################################### # _multiarray_umath module - multiarray part # ####################################################################### multiarray_deps = ([ join("src", "multiarray", "arrayobject.h"), join("src", "multiarray", "arraytypes.h"), join("src", "multiarray", "arrayfunction_override.h"), join("src", "multiarray", "buffer.h"), join("src", "multiarray", "calculation.h"), join("src", "multiarray", "common.h"), join("src", "multiarray", "convert_datatype.h"), join("src", "multiarray", "convert.h"), join("src", "multiarray", "conversion_utils.h"), join("src", "multiarray", "ctors.h"), join("src", "multiarray", "descriptor.h"), join("src", "multiarray", "dragon4.h"), join("src", "multiarray", "getset.h"), join("src", "multiarray", "hashdescr.h"), join("src", "multiarray", "iterators.h"), join("src", "multiarray", "mapping.h"), join("src", "multiarray", "methods.h"), join("src", "multiarray", "multiarraymodule.h"), join("src", "multiarray", "nditer_impl.h"), join("src", "multiarray", "number.h"), join("src", "multiarray", "refcount.h"), join("src", "multiarray", "scalartypes.h"), join("src", "multiarray", "sequence.h"), join("src", "multiarray", "shape.h"), join("src", "multiarray", "strfuncs.h"), join("src", "multiarray", "typeinfo.h"), join("src", "multiarray", "usertypes.h"), join("src", "multiarray", "vdot.h"), join("include", "numpy", "arrayobject.h"), join("include", "numpy", "_neighborhood_iterator_imp.h"), join("include", "numpy", "npy_endian.h"), join("include", "numpy", "arrayscalars.h"), join("include", "numpy", "noprefix.h"), join("include", "numpy", "npy_interrupt.h"), join("include", "numpy", "npy_3kcompat.h"), join("include", "numpy", "npy_math.h"), join("include", "numpy", "halffloat.h"), join("include", "numpy", "npy_common.h"), join("include", "numpy", "npy_os.h"), join("include", "numpy", "utils.h"), join("include", "numpy", "ndarrayobject.h"), join("include", "numpy", "npy_cpu.h"), join("include", "numpy", "numpyconfig.h"), join("include", "numpy", "ndarraytypes.h"), join("include", "numpy", "npy_1_7_deprecated_api.h"), # add library sources as distuils does not consider libraries # dependencies ] + npysort_sources + npymath_sources) multiarray_src = [ join("src", "multiarray", "alloc.c"), join("src", "multiarray", "arrayobject.c"), join("src", "multiarray", "arraytypes.c.src"), join("src", "multiarray", "array_assign_scalar.c"), join("src", "multiarray", "array_assign_array.c"), join("src", "multiarray", "arrayfunction_override.c"), join("src", "multiarray", "buffer.c"), join("src", "multiarray", "calculation.c"), join("src", "multiarray", "compiled_base.c"), join("src", "multiarray", "common.c"), join("src", "multiarray", "convert.c"), join("src", "multiarray", "convert_datatype.c"), join("src", "multiarray", "conversion_utils.c"), join("src", "multiarray", "ctors.c"), join("src", "multiarray", "datetime.c"), join("src", "multiarray", "datetime_strings.c"), join("src", "multiarray", "datetime_busday.c"), join("src", "multiarray", "datetime_busdaycal.c"), join("src", "multiarray", "descriptor.c"), join("src", "multiarray", "dragon4.c"), join("src", "multiarray", "dtype_transfer.c"), join("src", "multiarray", "einsum.c.src"), join("src", "multiarray", "flagsobject.c"), join("src", "multiarray", "getset.c"), join("src", "multiarray", "hashdescr.c"), join("src", "multiarray", "item_selection.c"), join("src", "multiarray", "iterators.c"), join("src", "multiarray", "lowlevel_strided_loops.c.src"), join("src", "multiarray", "mapping.c"), join("src", "multiarray", "methods.c"), join("src", "multiarray", "multiarraymodule.c"), join("src", "multiarray", "nditer_templ.c.src"), join("src", "multiarray", "nditer_api.c"), join("src", "multiarray", "nditer_constr.c"), join("src", "multiarray", "nditer_pywrap.c"), join("src", "multiarray", "number.c"), join("src", "multiarray", "refcount.c"), join("src", "multiarray", "sequence.c"), join("src", "multiarray", "shape.c"), join("src", "multiarray", "scalarapi.c"), join("src", "multiarray", "scalartypes.c.src"), join("src", "multiarray", "strfuncs.c"), join("src", "multiarray", "temp_elide.c"), join("src", "multiarray", "typeinfo.c"), join("src", "multiarray", "usertypes.c"), join("src", "multiarray", "vdot.c"), ] ####################################################################### # _multiarray_umath module - umath part # ####################################################################### def generate_umath_c(ext, build_dir): target = join(build_dir, header_dir, "__umath_generated.c") dir = os.path.dirname(target) if not os.path.exists(dir): os.makedirs(dir) script = generate_umath_py if newer(script, target): with open(target, "w") as f: f.write( generate_umath.make_code(generate_umath.defdict, generate_umath.__file__)) return [] umath_src = [ join("src", "umath", "umathmodule.c"), join("src", "umath", "reduction.c"), join("src", "umath", "funcs.inc.src"), join("src", "umath", "simd.inc.src"), join("src", "umath", "loops.h.src"), join("src", "umath", "loops.c.src"), join("src", "umath", "matmul.h.src"), join("src", "umath", "matmul.c.src"), join("src", "umath", "clip.h.src"), join("src", "umath", "clip.c.src"), join("src", "umath", "ufunc_object.c"), join("src", "umath", "extobj.c"), join("src", "umath", "cpuid.c"), join("src", "umath", "scalarmath.c.src"), join("src", "umath", "ufunc_type_resolution.c"), join("src", "umath", "override.c"), ] umath_deps = [ generate_umath_py, join("include", "numpy", "npy_math.h"), join("include", "numpy", "halffloat.h"), join("src", "multiarray", "common.h"), join("src", "multiarray", "number.h"), join("src", "common", "templ_common.h.src"), join("src", "umath", "simd.inc.src"), join("src", "umath", "override.h"), join(codegen_dir, "generate_ufunc_api.py"), ] config.add_extension( "_multiarray_umath", sources=multiarray_src + umath_src + npymath_sources + common_src + [ generate_config_h, generate_numpyconfig_h, generate_numpy_api, join(codegen_dir, "generate_numpy_api.py"), join("*.py"), generate_umath_c, generate_ufunc_api, ], depends=deps + multiarray_deps + umath_deps + common_deps, libraries=["npymath", "npysort"], extra_info=extra_info, ) ####################################################################### # umath_tests module # ####################################################################### config.add_extension("_umath_tests", sources=[join("src", "umath", "_umath_tests.c.src")]) ####################################################################### # custom rational dtype module # ####################################################################### config.add_extension( "_rational_tests", sources=[join("src", "umath", "_rational_tests.c.src")]) ####################################################################### # struct_ufunc_test module # ####################################################################### config.add_extension( "_struct_ufunc_tests", sources=[join("src", "umath", "_struct_ufunc_tests.c.src")], ) ####################################################################### # operand_flag_tests module # ####################################################################### config.add_extension( "_operand_flag_tests", sources=[join("src", "umath", "_operand_flag_tests.c.src")], ) config.add_data_dir("tests") config.add_data_dir("tests/data") config.make_svn_version_py() return config
def console(start_time): print("=========> You Have Logged In as Root") auti.sleep(2) print("") print("We trust you have received the usual lecture from dev_bides_mega") auti.sleep(1) print("It usually boils down to these three things:") auti.sleep(1) print("") auti.sleep(1) print(" #1) Respect the privacy of others.") auti.sleep(1) print(" #2) Think before you type.") auti.sleep(1) print(" #3) With great power comes great responsibility.") auti.sleep(1) print("") print("") auti.sleep(7) graffiti() auti.sleep(1) print( "______________________________________________________________________________________________________________________________" ) auti.sleep(1) print("") auti.sleep(1) print("") auti.sleep(1) while True: cmd = input("root@Konsole >> ") stop_time = time() if cmd.lower() == "exit": print("Bye Bye !!!!!") break if cmd.lower() == "sysinfo": print("CPU : " + platform.processor()) print("Python Version : " + platform.python_version()) # print("Python Build : "+platform.python_build()) print("Python Compiler : " + platform.python_compiler()) print("System Date : " + date.today().strftime("%d/%m/%y")) if int(datetime.now().strftime("%H")) > 12: h = int(datetime.now().strftime("%H")) - 12 postfix = " PM" else: h = int(datetime.now().strftime("%H")) postfix = " AM" print("System Time : " + str(h) + ":" + datetime.now().strftime("%M:%S") + postfix) print("System Up-Time : " + str(int(stop_time - start_time)) + " Seconds") if cmd.lower() == "clear": for a in range(0, 15): print("\n") if cmd.lower() == "cashinfo": a = Core_Data(0, 0, 0, 0, 0, 0, 0) array = a.Cash_Load() for c in range(len(array)): print("Rupees " + str(notes[c]) + " = " + str(array[c]) + " pcs") if cmd.lower() == "fun" or cmd.lower() == "graffiti": graffiti() if cmd.lower() == "help": print("sysinfo - This prints basic conditions of the program") print("clear - Clears the Terminal screen mess") print("fun - Prints the owner's beautiful graffiti") print("graffiti - Prints the owner's beautiful graffiti") print("cashinfo - Prints the current cash data in the machine") print("exit - Exit's the root console")
def test(verbosity=1, calculators=[], dir=None, display=True, stream=sys.stdout): test_calculator_names.extend(calculators) disable_calculators( [name for name in calc_names if name not in calculators]) ts = unittest.TestSuite() if dir is None: # ase/test (__path__[0]) testdir = __path__[0] else: if os.path.isdir(dir): # absolute path testdir = dir else: # relative to ase/test (__path__[0]) testdir = os.path.join(__path__[0], dir) files = glob(testdir + '/*') sdirtests = [] # tests from subdirectories: only one level assumed tests = [] for f in files: if os.path.isdir(f): # add test subdirectories (like calculators) sdirtests.extend(glob(os.path.join(testdir, f) + '/*.py')) else: # add py files in testdir if f.endswith('.py'): tests.append(f) tests.sort() sdirtests.sort() tests.extend(sdirtests) # run test subdirectories at the end lasttest = None # is COCu111.py in the current set for test in tests: if test.endswith('vtk_data.py'): continue if test.endswith('__init__.py'): continue if test.endswith('COCu111.py'): lasttest = test continue ts.addTest(ScriptTestCase(filename=test, display=display)) if lasttest: ts.addTest(ScriptTestCase(filename=lasttest, display=display)) operating_system = platform.system() + ' ' + platform.machine() operating_system += ' ' + ' '.join(platform.dist()) python = platform.python_version() + ' ' + platform.python_compiler() python += ' ' + ' '.join(platform.architecture()) print 'python %s on %s' % (python, operating_system) from ase.utils import devnull sys.stdout = devnull ttr = unittest.TextTestRunner(verbosity=verbosity, stream=stream) results = ttr.run(ts) sys.stdout = sys.__stdout__ return results
''' Created on 2016/3/3 16:44 @author: sodbvi ''' import platform profile = { 'Architecture: ': platform.architecture(), 'Linux Distribution: ': platform.linux_distribution(), 'mac_ver: ': platform.mac_ver(), 'machine: ': platform.machine(), 'node: ': platform.node(), 'platform: ': platform.platform(), 'processor: ': platform.processor(), 'python build: ': platform.python_build(), 'python compiler: ': platform.python_compiler(), 'python version: ': platform.python_version(), 'release: ': platform.release(), 'system: ': platform.system(), 'uname: ': platform.uname(), 'version: ': platform.version(), } for key in profile: print(key + str(profile[key]))
try: self.counter[0] += 1 except (Exception): pass def incFailed(self): try: self.counter[1] += 1 except (Exception): pass os.system('cls' if os.name == 'nt' else 'clear') print time.strftime("%b %d %Y %H:%M:%S") print 'Python Version: ', platform.python_version() print 'Compiler: ', platform.python_compiler() print 'Operating system: ', platform.platform() print 'Initiating monitor' print \ """ @@@@@@@@@ __\_\__ ____________|_____|_____________ \ / \ O O O O / |^^^^^^^\________________________/^^| i-----------------------------------I | /$$ /$$ | || $$ | $$ | || $$ /$$ /$$| $$ /$$$$$$$$|| || $$ | $$ | $$| $$|____ /$$/ |
# Initialize some variables. # pynio_vfile = "pynio_version.py" # PyNIO version file. pkgs_pth = get_python_lib() # # These variables are temporarily defined for readability. # The default FORTRAN_CALLING_METHOD is APPEND_UNDERSCORE. # APPEND_UNDERSCORE = 1 NO_APPEND_UNDERSCORE = 2 CAPS_NO_APPEND_UNDERSCORE = 3 if sys.platform == "linux2" and os.uname()[-1] == "x86_64" and \ platform.python_compiler()[:5] == "GCC 4": LIBRARIES.append('gfortran') elif sys.platform == "irix6-64": LIBRARIES.append('ftn') LIBRARIES.append('fortran') LIBRARIES.append('sz') elif sys.platform == "sunos5": LIBRARIES.append('fsu') LIBRARIES.append('sunmath') elif sys.platform == "aix5": os.putenv('OBJECT_MODE',"64") LIBRARIES.append('xlf90') LIB_MACROS.append(('FORTRAN_CALLING_METHOD', NO_APPEND_UNDERSCORE))
import platform print(platform.python_compiler())
match = re.search(r"^GNU gdb.*?\b(\d+)\.(\d+)", version) if match is None: raise Exception("unable to parse GDB version: %r" % version) return (version, int(match.group(1)), int(match.group(2))) gdb_version, gdb_major_version, gdb_minor_version = get_gdb_version() if gdb_major_version < 7: raise unittest.SkipTest("gdb versions before 7.0 didn't support python " "embedding. Saw %s.%s:\n%s" % (gdb_major_version, gdb_minor_version, gdb_version)) if not sysconfig.is_python_build(): raise unittest.SkipTest("test_gdb only works on source builds at the moment.") if 'Clang' in platform.python_compiler() and sys.platform == 'darwin': raise unittest.SkipTest("test_gdb doesn't work correctly when python is" " built with LLVM clang") if ((sysconfig.get_config_var('PGO_PROF_USE_FLAG') or 'xxx') in (sysconfig.get_config_var('PY_CORE_CFLAGS') or '')): raise unittest.SkipTest("test_gdb is not reliable on PGO builds") # Location of custom hooks file in a repository checkout. checkout_hook_path = os.path.join(os.path.dirname(sys.executable), 'python-gdb.py') PYTHONHASHSEED = '123' def cet_protection():
if __name__ == '__main__': # Create a multiprocessing Pool pool = mp.Pool() pool.map(collector.analyze, period) print("[%.4fs] Analyzing complete. Zipping dictionaries..." % (elapsed())) dictionary.zipper(start_month, start_year, end_month, end_year) final_time = datetime.timedelta(seconds=elapsed()) print("[%.4fs] ThaiTrend: Emoji has finished in %s " % (elapsed(), str(final_time))) print("Next: Run graph.py to visualize data into graphs.") START_TIME = time.time() print("============ ThaiTrend: Emoji (v1.1) is running... ============") print() print("================= Current machine information =================") print('** Python version\t:', platform.python_version()) print('** Compiler\t\t:', platform.python_compiler()) print('** System\t\t:', platform.system(), platform.release()) print('** Processor\t\t:', platform.processor()) print('** CPU counts\t\t:', mp.cpu_count()) print('** Interpreter\t\t:', platform.architecture()[0]) print() main()
from __future__ import division, print_function import os import platform import sys from os.path import join from numpy.distutils.system_info import platform_bits is_msvc = (platform.platform().startswith('Windows') and platform.python_compiler().startswith('MS')) def configuration(parent_package='', top_path=None): from numpy.distutils.misc_util import Configuration, get_mathlibs config = Configuration('random', parent_package, top_path) def generate_libraries(ext, build_dir): config_cmd = config.get_config_cmd() libs = get_mathlibs() if sys.platform == 'win32': libs.extend(['Advapi32', 'Kernel32']) ext.libraries.extend(libs) return None # enable unix large file support on 32 bit systems # (64 bit off_t, lseek -> lseek64 etc.) if sys.platform[:3] == "aix": defs = [('_LARGE_FILES', None)] else: defs = [('_FILE_OFFSET_BITS', '64'), ('_LARGEFILE_SOURCE', '1'),
def get_python_compiler(): '''Returns a string identifying the compiler used for compiling Python''' return platform.python_compiler()
# Read in list of modules from cmd line mod_list = sys.argv[1:] # Get version info for each module in mod_list mod_info = [] for mod in mod_list: mod_info.append(get_distribution(mod)) # Print all information print '\nGeneral Information...' print 'Author: {0}'.format(author) print 'Date: {0}'.format(time_stamp) print '\nPython Information...' print 'CPython: {0}'.format(platform.python_version()) print 'IPython: {0}'.format(IPython.__version__) print '\nModule Information...' for mod in range(len(mod_info)): print mod_info[mod] print '\nSystem Information...' print 'Compiler: {0}'.format(platform.python_compiler()) print 'System: {0}'.format(platform.system()) print 'Release: {0}'.format(platform.release()) print 'Machine: {0}'.format(platform.machine()) print 'Processor: {0}'.format(platform.processor()) print 'CPU Cores: {0}'.format(cpu_count()) print 'Interpreter: {0}'.format(platform.architecture()[0])