def CanMonitorPower(self):
family, model = map(int, re.match(".+ Family ([0-9]+) Model ([0-9]+)", platform.processor()).groups())
if not _IsSandyBridgeOrLater(platform.processor(), family, model):
logging.info("Cannot monitor power: pre-Sandy Bridge CPU.")
return False
return self._CheckMSRs()
def CanMonitorPower(self):
if not win32event:
return False
# TODO(dtu): This should work on Windows 7, but it's flaky on the bots.
# http://crbug.com/336558
windows_8_or_later = (
self._backend.GetOSName() == 'win' and
self._backend.GetOSVersionName() >= platform_backend.WIN8)
if not windows_8_or_later:
return False
# This check works on Windows only.
family, model = map(int, re.match('.+ Family ([0-9]+) Model ([0-9]+)',
platform.processor()).groups())
# Model numbers from:
# https://software.intel.com/en-us/articles/intel-architecture-and-processor-identification-with-cpuid-model-and-family-numbers
# http://www.speedtraq.com
sandy_bridge_or_later = ('Intel' in platform.processor() and family == 6 and
(model in (0x2A, 0x2D) or model >= 0x30))
if not sandy_bridge_or_later:
return False
if not IppetPath():
return False
return True
def performance(attribute):
""" A little smater routing system.
"""
data = None
if attribute == 'system':
data = { 'system': platform.system() }
elif attribute == 'processor':
data = { 'processor': platform.processor() }
elif attribute in ['cpu_count', 'cpucount'] :
data = { 'cpu_count': psutil.cpu_count() }
elif attribute == 'machine':
data = { 'machine': platform.machine() }
elif attribute in ['virtual_mem', 'virtualmem']:
data = { 'virtual_mem': psutil.virtual_memory().total }
elif attribute in ['virtual_mem_gb', 'virtualmemgb']:
data = { 'virtual_mem_gb': psutil.virtual_memory().total / (1024.0 ** 3) }
elif attribute == 'all':
data = {
'system': platform.system(),
'processor': platform.processor(),
'cpu_count': psutil.cpu_count(),
'machine': platform.machine(),
'virtual_mem': psutil.virtual_memory().total,
'virtual_mem_gb': psutil.virtual_memory().total / (1024.0 ** 3),
}
packet = json.dumps(data)
resp = Response(packet, status=200, mimetype='application/json')
return(resp)
def _get_processor(self):
'''Get type of processor
http://stackoverflow.com/questions/4842448/getting-processor-information-in-python
'''
out = None
if platform.system() == "Windows":
out = platform.processor()
elif platform.system() == "Darwin":
path = os.environ['PATH']
os.environ['PATH'] = os.environ['PATH'] + os.pathsep + '/usr/sbin'
try:
command = "sysctl -n machdep.cpu.brand_string"
out = subprocess.check_output(command, shell=True).strip().decode()
finally:
os.environ['PATH'] = path
elif platform.system() == "Linux":
command = "cat /proc/cpuinfo"
all_info = subprocess.check_output(command, shell=True).strip().decode()
for line in all_info.split("\n"):
if "model name" in line:
out = re.sub(".*model name.*:", "", line, 1)
if out is None:
return platform.processor()
else:
return out
def CanMonitorPower(self):
# IPPET disabled because of flakiness (crbug.com/336558).
if True:
return False
if not win32event:
return False
windows_7_or_later = (
self._backend.GetOSName() == 'win' and
self._backend.GetOSVersionName() >= platform_backend.WIN7)
if not windows_7_or_later:
return False
# This check works on Windows only.
family, model = map(int, re.match('.+ Family ([0-9]+) Model ([0-9]+)',
platform.processor()).groups())
# Model numbers from:
# https://software.intel.com/en-us/articles/intel-architecture-and- \
# processor-identification-with-cpuid-model-and-family-numbers
# http://www.speedtraq.com
sandy_bridge_or_later = ('Intel' in platform.processor() and family == 6 and
(model in (0x2A, 0x2D) or model >= 0x30))
if not sandy_bridge_or_later:
return False
if not IppetPath():
return False
return True
def getArch() :
"""
Return the NuPIC architecture name.
Note that this is redundant with the calculation in configure.ac
"""
if sys.platform == "linux2":
#
# platform.processor() vs. platform.machine() is a bit of a mystery
# On linux systems, they ultimately translate to uname -p and uname -m, respectively.
# These options and their possible results aren't clearly documented.
# uname -p doesn't exist in some versions of uname (debian 3.x)
# and returns "unknown" on others (Ubuntu). Python translates "unknown" to "".
# uname -p may also return "athlon" or other random words.
#
cpu = platform.machine()
if cpu not in ["i686", "i386", "x86_64"]:
cpu = platform.processor()
if cpu in ["i686", "i386"]:
return "linux32"
elif cpu == "x86_64":
return "linux64"
else:
raise Exception("Unknown cpu for linux system. platform.machine() = %s; platform.processor() = %s" % (platform.machine(), platform.processor()))
elif sys.platform == "darwin":
cpu = platform.processor()
if cpu == "powerpc":
raise Exception("Unsupported CPU %s for darwin system" %(cpu));
else:
return "darwin64"
elif sys.platform == "win32":
return "win32"
else:
raise Exception("Unknown os %s" % sys.platform)
def __init__(self, main_win, target_controller, x86_slice_mode=False):
super(PartEditScreen, self).__init__(main_win)
global LOGGER
LOGGER = logging.getLogger(INSTALL_LOGGER_NAME)
self.x86_slice_mode = x86_slice_mode
self.is_x86 = (platform.processor() == "i386")
self.header_text = platform.processor()
if self.x86_slice_mode: # x86, Slice within a partition
self.instance = ".slice"
self.header_text = PartEditScreen.HEADER_x86_SLICE
self.paragraph_text = PartEditScreen.SLICE_PARAGRAPH
self.destroy_text = PartEditScreen.SLICE_DESTROY_TEXT
self.help_data = PartEditScreen.X86_SLICE_HELP
elif self.is_x86: # x86, Partition on disk
self.header_text = PartEditScreen.HEADER_x86_PART
self.paragraph_text = PartEditScreen.PARTITION_PARAGRAPH
self.destroy_text = PartEditScreen.PART_DESTROY_TEXT
self.help_data = PartEditScreen.X86_PART_HELP
else: # SPARC (Slice on disk)
self.header_text = PartEditScreen.HEADER_SPARC_SLICE
self.paragraph_text = PartEditScreen.SLICE_PARAGRAPH
self.destroy_text = PartEditScreen.SLICE_DESTROY_TEXT
self.help_data = PartEditScreen.SPARC_HELP
self.help_format = " %s"
self.disk_win = None
self.tc = target_controller
def platform_infos(self):
# (TT) codice clandestino di prova
#http://www.doughellmann.com/PyMOTW/resource/
#print "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
#try:
# import resource
# print "res0", resource.getrusage(0)
# print "res1", resource.getrusage(1)
#except ImportError:
# print "miu mio!"
#print "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
from src.engine import engine
lines = []
dt = datetime.datetime.now()
lines.append("Platform infos on %d %d %d" % (dt.year, dt.month, dt.day))
lines.append("Bit Architecture: %s" % str(platform.architecture()))
lines.append("Machine Type: %s" % platform.machine())
lines.append("Network Node: %s" % platform.node())
if platform.processor():
lines.append("(Real) Processor: %s" % platform.processor())
lines.append("System Name: %s" % platform.system())
lines.append("System Version: %s" % platform.version())
lines.append("System Release: %s" % platform.release())
if any(platform.dist()):
lines.append("Linux Distribution: %s" % str(platform.dist()))
if any(platform.libc_ver()):
lines.append("Linux Libc Version: %s" % str(platform.libc_ver()))
lines.append("Python Build: %s" % str(platform.python_build()))
lines.append("Python Compiler: %s" % platform.python_compiler())
lines.append("Python Version: %s" % platform.python_version())
lines.append("Python Executable: %s" % sys.executable)
lines.append("Twisted Version: %s" % twisted_version.base())
if engine.epoll:
lines.append("Reactor: epoll")
else:
lines.append("Reactor: select")
lines.append("PIL Version: %s" % Image.VERSION)
if numpy_version:
lines.append("Numpy Version: %s" % numpy_version)
lines.append("\n")
lines = "\n".join(lines)
filename = "log/platform_infos.txt"
try:
platform_log_file = open(filename, "a")
platform_log_file.write(lines + "\n")
platform_log_file.close()
except IOError:
print "Impossibile aprire il file %s in scrittura" % filename
print lines
def CanMonitorPower(self):
family, model = map(int, re.match('.+ Family ([0-9]+) Model ([0-9]+)',
platform.processor()).groups())
if not _IsSandyBridgeOrLater(platform.processor(), family, model):
logging.info('Cannot monitor power: pre-Sandy Bridge CPU.')
return False
try:
return self._CheckMSRs()
finally:
# Since _CheckMSRs() starts the MSR server on win platform, we must close
# it after checking to avoid leaking msr server process.
self._backend.CloseMsrServer()
def get_system_stats():
systemStats = {
'machine': platform.machine(),
'platform': sys.platform,
'processor': platform.processor(),
'pythonV': platform.python_version(),
}
platf = sys.platform
if Platform.is_linux(platf):
grep = subprocess.Popen(['grep', 'model name', '/proc/cpuinfo'], stdout=subprocess.PIPE, close_fds=True)
wc = subprocess.Popen(['wc', '-l'], stdin=grep.stdout, stdout=subprocess.PIPE, close_fds=True)
systemStats['cpuCores'] = int(wc.communicate()[0])
if Platform.is_darwin(platf):
systemStats['cpuCores'] = int(subprocess.Popen(['sysctl', 'hw.ncpu'], stdout=subprocess.PIPE, close_fds=True).communicate()[0].split(': ')[1])
if Platform.is_freebsd(platf):
systemStats['cpuCores'] = int(subprocess.Popen(['sysctl', 'hw.ncpu'], stdout=subprocess.PIPE, close_fds=True).communicate()[0].split(': ')[1])
if Platform.is_linux(platf):
systemStats['nixV'] = platform.dist()
elif Platform.is_darwin(platf):
systemStats['macV'] = platform.mac_ver()
elif Platform.is_freebsd(platf):
version = platform.uname()[2]
systemStats['fbsdV'] = ('freebsd', version, '') # no codename for FreeBSD
elif Platform.is_win32(platf):
systemStats['winV'] = platform.win32_ver()
return systemStats
def index():
""" The main Flask entry-point (/) for the Stallion server. """
data = {"breadpath": [Crumb("Main")]}
data.update(get_shared_data())
data["menu_home"] = "active"
sys_info = {
"Python Platform": sys.platform,
"Python Version": sys.version,
"Python Prefix": sys.prefix,
"Machine Type": platform.machine(),
"Platform": platform.platform(),
"Processor": platform.processor(),
}
try:
sys_info["Python Implementation"] = platform.python_implementation()
except:
pass
sys_info["System"] = platform.system()
sys_info["System Arch"] = platform.architecture()
data["system_information"] = sys_info
return render_template("system_information.html", **data)
def __repr__(self):
import platform
from itertools import chain
out = []
out += ['PyAbel benchmark run on {}\n'.format(platform.processor())]
LABEL_FORMAT = '|'.join([' Implementation '] \
+ [' n = {:<12} '.format(ni) for ni in self.n])
TR_ROW_FORMAT = '|'.join(['{:>15} '] + [ ' {:8.1e} ' ]*len(self.n))
BS_ROW_FORMAT = '|'.join(['{:>15} '] + [ ' {:8.1e} ({:8.1e}) ' ]*len(self.n))
SEP_ROW = ' ' + '-'*(22 + (17+1)*len(self.n))
HEADER_ROW = ' ========= {:>10} Abel implementations ==========\n' \
' time to solution [s] -> transform (basis sets generation)\n'
def print_benchmark(name, res):
out = [HEADER_ROW.format(name)]
if res:
out += [LABEL_FORMAT]
out += [SEP_ROW]
for name, row in res.items():
if 'bs' in row:
pars = list(chain(*zip(row['tr'], row['bs'])))
out += [BS_ROW_FORMAT.format(name, *pars)]
else:
out += [TR_ROW_FORMAT.format(name, *row['tr'])]
return out
out += print_benchmark('Direct', self.fabel)
out += ['']
out += print_benchmark('Inverse', self.iabel)
return '\n'.join(out)
def download_node(node_directory, node_version=None):
node_exe = os.path.join(node_directory, "node")
if os.path.lexists(node_exe):
print "Doing nothing as %s exists" % node_exe
return os.path.realpath(node_exe)
if not node_version:
json_file = urllib.urlopen("https://nodejs.org/download/release/index.json").read()
versions = json.loads(json_file)
lts_versions = [x["version"] for x in versions if x["lts"]]
lts_versions.sort(reverse=True)
node_version = lts_versions[0]
arch_mappings = {
"x86_64": "x64",
"x86": "x86"
}
arch = arch_mappings[platform.processor()]
download_url = "https://nodejs.org/download/release/{0}/node-{0}-linux-{1}.tar.gz".format(node_version,arch)
if not os.path.exists(node_directory):
os.mkdir(node_directory)
node_extract_path = os.path.join(node_directory, "node-{0}-linux-{1}".format(node_version, arch), "bin", "node")
node_download_file = os.path.join(node_directory, "node-{0}-linux-{1}.tar.gz".format(node_version, arch))
url_downloader = urllib.URLopener()
url_downloader.retrieve(download_url, node_download_file)
tar = tarfile.open(node_download_file)
tar.extractall(path=node_directory)
os.symlink(os.path.abspath(node_extract_path), node_exe)
return os.path.realpath(node_exe)
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 test_compilation(cfile, compiler=None, **compiler_attrs):
"""Test simple compilation with given settings"""
cc = get_compiler(compiler, **compiler_attrs)
efile, ext = os.path.splitext(cfile)
cpreargs = lpreargs = []
if sys.platform == 'darwin':
# use appropriate arch for compiler
if platform.architecture()[0]=='32bit':
if platform.processor() == 'powerpc':
cpu = 'ppc'
else:
cpu = 'i386'
cpreargs = ['-arch', cpu]
lpreargs = ['-arch', cpu, '-undefined', 'dynamic_lookup']
else:
# allow for missing UB arch, since it will still work:
lpreargs = ['-undefined', 'dynamic_lookup']
if sys.platform == 'sunos5':
if platform.architecture()[0]=='32bit':
lpreargs = ['-m32']
else:
lpreargs = ['-m64']
extra = compiler_attrs.get('extra_compile_args', [])
extra += ['--std=c++11']
objs = cc.compile([cfile], extra_preargs=cpreargs, extra_postargs=extra)
cc.link_executable(objs, efile, extra_preargs=lpreargs)
return efile
def get_depends(args):
for package in args: # For each package in the list of arguments
try:
tmp = tuple(package.split(":")) # Ethan wrote this
parameters = tmp + (None,) * (3 - len(tmp)) # This converts the "name:version:arch" into a tuple
package = { # This converts the tuple into a dictionary so we can use default values
"name": parameters[0],
"version": parameters[1] if parameters[1] != None else "Latest", # If there is no second value, set the value of "version" to "Latest"
"arch": parameters[2] if parameters[2] != None else platform.processor() # If there is no third value, set "arch" to the current processor
}
if not database.TableExists(package["name"]): # If the package doesn't exist, throw an error
raise Exception("Package doesn't exist in database.")
for version in database.Dump(package["name"]): # For each version of that package
if version["Version"] == package["version"]: # If this is the version we're attempting to install
if version["Version"] != "Latest": # and it's not "Latest"
screen.write_line(version["Dependencies"] + "\n") # FIXME CHANGEME TODO print the dependencies
else: # On the other hand, if this IS "Latest"
for version_ in database.Dump(package["name"]): # For each version in the package
if version_["Version"] == version["LatestVersion"]: # If this is the latest version
screen.write_line(str(version_["Dependencies"]) + "\n") # FIXME CHANGEME TODO print the dependencies
print(package["name"], package["version"], package["arch"], "\n") # FIXME CHANGEME TODO print the package name, version and arch
except:
print("Failed to locate package " + package["name"] + ":" + package["version"] + ":" + package["arch"])
print(traceback.format_exc())
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 setUp(self):
"""
Get the number of cores and threads per core
Set the SMT value to 4/8
"""
if 'ppc' not in platform.processor():
self.cancel("Processor is not ppc64")
self.nfail = 0
self.CORES = process.system_output("lscpu | grep 'Core(s) per socket:'"
"| awk '{print $4}'", shell=True)
self.SOCKETS = process.system_output("lscpu | grep 'Socket(s):'"
"| awk '{print $2}'", shell=True)
self.THREADS = process.system_output("lscpu | grep 'Thread(s) per core"
":'| awk '{print $4}'",
shell=True)
self.T_CORES = int(self.CORES) * int(self.SOCKETS)
self.log.info(" Cores = %s and threads = %s "
% (self.T_CORES, self.THREADS))
process.system("echo 8 > /proc/sys/kernel/printk", shell=True,
ignore_status=True)
self.max_smt = 4
if cpu.get_cpu_arch().lower() == 'power8':
self.max_smt = 8
if cpu.get_cpu_arch().lower() == 'power6':
self.max_smt = 2
process.system_output("ppc64_cpu --smt=%s" % self.max_smt, shell=True)
self.path = "/sys/devices/system/cpu"
def set_properties(self):
self._properties = SortedDict()
if LSB:
self.add_property(Property('is_lsb', _(u'LSB OS'), True))
self.add_property(Property('distributor_id', _(u'Distributor ID'), lsb_release('-i','-s')))
self.add_property(Property('description', _(u'Description'), lsb_release('-d','-s')))
self.add_property(Property('release', _(u'Release'), lsb_release('-r','-s')))
self.add_property(Property('codename', _(u'Codename'), lsb_release('-c','-s')))
self.add_property(Property('sysinfo', _(u'System info'), uname('-a')))
else:
self.add_property(Property('is_posix', _(u'POSIX OS'), False))
self.add_property(Property('architecture', _(u'OS architecture'), platform.architecture()))
self.add_property(Property('python_version', _(u'Python version'), platform.python_version()))
self.add_property(Property('hostname', _(u'Hostname'), platform.node()))
self.add_property(Property('platform', _(u'Platform'), sys.platform))
self.add_property(Property('machine', _(u'Machine'), platform.machine()))
self.add_property(Property('processor', _(u'Processor'), platform.processor()))
self.add_property(Property('cpus', _(u'Number of CPUs'), psutil.NUM_CPUS))
self.add_property(Property('total_phymem', _(u'Total physical memory'), pretty_size(psutil.TOTAL_PHYMEM)))
self.add_property(Property('disk_partitions', _(u'Disk partitions'), '; '.join(['%s %s %s %s' % (partition.device, partition.mountpoint, partition.fstype, partition.opts) for partition in psutil.disk_partitions()])))
try:
self.add_property(Property('tesseract', _(u'tesseract version'), pbs.tesseract('-v').stderr))
except pbs.CommandNotFound:
self.add_property(Property('tesseract', _(u'tesseract version'), _(u'not found')))
try:
self.add_property(Property('unpaper', _(u'unpaper version'), pbs.unpaper('-V').stdout))
except pbs.CommandNotFound:
self.add_property(Property('unpaper', _(u'unpaper version'), _(u'not found')))
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 runCommands():
tmp_dir="./tmp_install"
os.chdir(tmp_dir)
cpu_info=platform.processor()
#Iterates over list, running statements for each item in the list
color="YELLOW"
temp_message= "Start operation for Redis installation:"
print (colorstr(temp_message, color))
for cmd in cmds_redis:
subprocess.call(cmd, shell=True)
temp_message= "I found this CPU class: "+cpu_info
print (colorstr(temp_message, color))
if cpu_info == "x86_64":
temp_message= "Starting 64Bit installation of WkhtmlToPdf:"
print (colorstr(temp_message, color))
for cmd in cmds_wkhtml_64:
subprocess.call(cmd, shell=True)
else:
temp_message= "Starting installation of 32Bit version of WkhtmlToPdf:"
print (colorstr(temp_message, color))
for cmd in cmds_wkhtml_32:
subprocess.call(cmd, shell=True)
os.chdir("../")
try:
shutil.rmtree(tmp_dir) # delete directory
except OSError as exc:
if exc.errno != 2: # code 2 - no such file or directory
raise # re-raise exception
def _get_build_platform():
plat = pkg_resources._get_build_platform()
if sys.platform == 'darwin':
# Assert OS X version is new enough
current_minor_ver = int( platform.mac_ver()[0].split( '.' )[1] )
assert current_minor_ver >= 6, 'Galaxy is not compatible with Mac OS X < 10.6 (your version is %s)' % platform.mac_ver()[0]
# Python build target may be even older, but this will prevent it from
# fetching our 10.6+ eggs, so fix if necessary (newer versions will be
# fine)
plat_split = plat.split( '-' )
build_minor_ver = int( plat_split[1].split( '.' )[1] )
if build_minor_ver < 6:
plat_split[1] = '10.6'
# Our intel (dual arch) eggs will work fine on single-arch builds
if plat_split[-1] in ( 'i386', 'x86_64' ):
plat_split[-1] = 'intel'
# Ditto universal (if you're not on PPC)
if plat_split[-1] == 'universal' and platform.processor() != 'powerpc':
plat_split[-1] = 'intel'
plat = '-'.join( plat_split )
elif sys.platform == "linux2" and sys.maxint < 2 ** 31 and plat.endswith( '-x86_64' ):
# 32 bit Python on 64 bit Linux
plat = plat.replace( '-x86_64', '-i686' )
if not (plat.endswith('-ucs2') or plat.endswith('-ucs4')):
if sys.maxunicode > 2 ** 16:
plat += '-ucs4'
else:
plat += '-ucs2'
return plat
def pull_os():
"""Find information about the host's operating system.
Returns:
A tuple of a dictionary of the OS information, and the system's processor.
Example:
(
{
'architecture': 'nt',
'platform': 'Windows',
'release': {
'product_name': 'Windows 8',
'service_pack': 0,
'version_number': '6.2'
},
'Intel64 Family 6 Model 58 Stepping 9, GenuineIntel'
)
"""
os_info = {}
os_info['architecture'] = os.name
os_info['platform'] = hiveary.info.current_system
if hiveary.info.current_system == 'Windows':
os_info['release'] = wincom.get_version_info()
else:
os_info['release'] = platform.release()
processor = platform.processor()
return (os_info, processor)
def get_info_in_json():
json_str="{\n"
json_str+=" \"os\":\""+platform.system()+"\",\n"
json_str+=" \"processor\":\""+platform.processor()+"\",\n"
json_str+=" \"release\":\""+platform.release()+"\",\n"
json_str+=" \"uname\":\""
items=platform.uname()
for item in items:
json_str+=item+";"
json_str+="\",\n"
items=platform.linux_distribution()
json_str+=" \"distro\":\""
for item in items:
json_str+=item+";"
json_str+="\",\n"
items=platform.libc_ver()
json_str+=" \"libc\":\""
for item in items:
json_str+=item+";"
json_str+="\",\n"
json_str+=" \"tram\":\""+get_total_ram()+"\",\n"
json_str+=" \"ncpu\":\""+str(multiprocessing.cpu_count())+"\",\n"
json_str+=" \"uptime\":\""+get_uptime()+"\",\n"
json_str+=" \"date\":\""+datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")+"\",\n"
json_str+=" \"badips\":\""+get_banned_ip_address()+"\",\n"
json_str+=" \"load\":\""+get_load()+"\"\n"
json_str+="}\n"
return json_str
def device_spec():
print(platform.machine())
print(platform.version())
print(platform.platform())
print(platform.uname())
print(platform.system())
print(platform.processor())
def debug_details():
""" Show detailed version/debugging information. """
import platform
logging.info('\nPLATFORM')
logging.info('os: %s %s %s', plat.system, platform.processor(), platform.version())
logging.info('python: %s %s', sys.version.replace('\n',''), ' '.join(platform.architecture()))
logging.info('\nMODULES')
# try numpy before pygame to avoid strange ImportError on FreeBSD
modules = ('numpy', 'win32api', 'pygame', 'curses', 'pexpect', 'serial', 'parallel')
for module in modules:
try:
m = __import__(module)
except ImportError:
logging.info('%s: --', module)
else:
for version_attr in ('__version__', 'version', 'VERSION'):
try:
version = getattr(m, version_attr)
logging.info('%s: %s', module, version)
break
except AttributeError:
pass
else:
logging.info('available\n')
if plat.system != 'Windows':
logging.info('\nEXTERNAL TOOLS')
tools = ('lpr', 'paps', 'beep', 'xclip', 'xsel', 'pbcopy', 'pbpaste')
for tool in tools:
try:
location = subprocess.check_output('command -v %s' % tool, shell=True).replace('\n','')
logging.info('%s: %s', tool, location)
except Exception as e:
logging.info('%s: --', tool)
def get_debug_info(civcoms):
code = "<html><head><meta http-equiv=\"refresh\" content=\"20\">" \
+ "<link href='/css/bootstrap.min.css' rel='stylesheet'></head>" \
+ "<body><div class='container'>" \
+ "<h2>Freeciv WebSocket Proxy Status</h2>" \
+ "<font color=\"green\">Process status: OK</font><br>"
code += "<b>Process Uptime: " + \
str(int(time.time() - startTime)) + " s.</b><br>"
code += ("Python version: %s %s (%s)<br>" % (
platform.python_implementation(),
platform.python_version(),
platform.python_build()[0],
))
cpu = ' '.join(platform.processor().split())
code += ("Platform: %s %s on '%s' <br>" % (
platform.machine(),
platform.system(),
cpu))
code += ("Tornado version %s <br>" % (tornado_version))
try:
f = open("/proc/loadavg")
contents = f.read()
code += "Load average: " + contents
f.close()
except:
print("Cannot open uptime file: /proc/uptime")
try:
code += "<h3>Memory usage:</h3>"
code += "Memory: " + str(memory() / 1048576) + " MB <br>"
code += "Resident: " + str(resident() / 1048576) + " MB <br>"
code += "Stacksize: " + str(stacksize() / 1048576) + " MB <br>"
try:
code += "Garabage collection stats: " + str(gc.get_stats()) + " <br>"
code += "Garabage list: " + str(gc.garbage) + " <br>"
except AttributeError:
pass
code += ("<h3>Logged in users (count %i) :</h3>" % len(civcoms))
for key in list(civcoms.keys()):
code += (
"username: <b>%s</b> <br>IP:%s <br>Civserver: (%d)<br>Connect time: %d<br><br>" %
(civcoms[key].username,
civcoms[key].civwebserver.ip,
civcoms[key].civserverport,
time.time() -
civcoms[key].connect_time))
except:
print(("Unexpected error:" + str(sys.exc_info()[0])))
raise
code += "</div></body></html>"
return code
def __init__(self, name, source_path, cmds, timeout, compiler_id = 0):
self.name = name
self.source_path = Test.uncygdrive(source_path)
self.expect_path = Test.source_to_expect_path(self.source_path)
self.source_directory, self.fname = os.path.split(self.source_path)
self.temp_directory = os.path.join(self.source_directory, "Output")
self.temp_output_path = os.path.join(self.temp_directory, self.fname + ".tmp")
self.output = None
self.expected = Test.read_normalize(self.expect_path)
self.cmds = cmds
self.timeout = timeout
self.compiler_id = compiler_id
self.cmds = [cmd.replace("%s", self.source_path) for cmd in self.cmds]
self.cmds = [cmd.replace("%S", self.source_directory) for cmd in self.cmds]
self.cmds = [cmd.replace("%t", self.temp_output_path) for cmd in self.cmds]
self.cmds = [cmd.replace("%T", self.temp_directory) for cmd in self.cmds]
self.status = TestStatus.PENDING
self.proc_info = platform.processor()
self.time, self.suite_time = None, None
self.njobs, self.returncodes = None, []
self.start, self.end, self.duration = None, None, None
def test_compilation(cfile, compiler=None, **compiler_attrs):
"""Test simple compilation with given settings"""
if compiler is None or isinstance(compiler, str):
cc = ccompiler.new_compiler(compiler=compiler)
customize_compiler(cc)
if cc.compiler_type == 'mingw32':
customize_mingw(cc)
else:
cc = compiler
for name, val in compiler_attrs.items():
setattr(cc, name, val)
efile, ext = os.path.splitext(cfile)
cpreargs = lpreargs = None
if sys.platform == 'darwin':
# use appropriate arch for compiler
if platform.architecture()[0]=='32bit':
if platform.processor() == 'powerpc':
cpu = 'ppc'
else:
cpu = 'i386'
cpreargs = ['-arch', cpu]
lpreargs = ['-arch', cpu, '-undefined', 'dynamic_lookup']
else:
# allow for missing UB arch, since it will still work:
lpreargs = ['-undefined', 'dynamic_lookup']
extra = compiler_attrs.get('extra_compile_args', None)
objs = cc.compile([cfile],extra_preargs=cpreargs, extra_postargs=extra)
cc.link_executable(objs, efile, extra_preargs=lpreargs)
return efile
def get_processor():
"""计算机处理器信息"""
return platform.processor()
# Report
# OS version
print_header_1('OS information')
print(Fore.GREEN + '[INFO]\t linux_distribution : ' +
' '.join(str(p) for p in platform.linux_distribution()))
# OS Memory
print(Fore.GREEN +
'[INFO]\t OS total memory : {0}'.format(format_bytes(mem.total)))
print(Fore.BLUE + '[INFO]\t node : {0}'.format(platform.node()))
print(Fore.GREEN +
'[INFO]\t release : {0}'.format(platform.release()))
print(Fore.BLUE +
'[INFO]\t machine : {0}'.format(platform.machine()))
print(Fore.BLUE +
'[INFO]\t processor : {0}'.format(platform.processor()))
# Overcommit
def check_overcommit_memory():
overcommit_memory = int(get_value_proc('/proc/sys/vm/overcommit_memory'))
if overcommit_memory != 2:
print_report_bad(
"Memory overcommitment is allowed on the system. This can lead to OOM Killer killing some PostgreSQL process, which will cause a PostgreSQL server restart (crash recovery)"
)
add_advice(
'sysctl', 'urgent',
'Try to echo vm.overcommit_memory=2 > /etc/sysctl.d/20-overcommit_memory.conf; sysctl -p - This will disable memory overcommitment and avoid postgresql killed by OOM killer.'
)
overcommit_ratio = int(get_value_proc('/proc/sys/vm/overcommit_ratio'))
# print_report_info("sysctl vm.overcommit_ratio={0}".format(overcommit_ratio))
def on_powerpc():
""" True if we are running on a Power PC platform."""
return platform.processor() == 'powerpc' or \
platform.machine().startswith('ppc')
def set_properties(self):
self._properties = SortedDict()
if LSB:
self.add_property(Property('is_lsb', _(u'LSB OS'), True))
self.add_property(
Property('distributor_id', _(u'Distributor ID'),
lsb_release('-i', '-s')))
self.add_property(
Property('description', _(u'Description'),
lsb_release('-d', '-s')))
self.add_property(
Property('release', _(u'Release'), lsb_release('-r', '-s')))
self.add_property(
Property('codename', _(u'Codename'), lsb_release('-c', '-s')))
self.add_property(
Property('sysinfo', _(u'System info'), uname('-a')))
else:
self.add_property(Property('is_posix', _(u'POSIX OS'), False))
self.add_property(
Property('architecture', _(u'OS architecture'),
platform.architecture()))
self.add_property(
Property('python_version', _(u'Python version'),
platform.python_version()))
self.add_property(Property('hostname', _(u'Hostname'),
platform.node()))
self.add_property(Property('platform', _(u'Platform'), sys.platform))
self.add_property(
Property('machine', _(u'Machine'), platform.machine()))
self.add_property(
Property('processor', _(u'Processor'), platform.processor()))
self.add_property(
Property('cpus', _(u'Number of CPUs'), psutil.NUM_CPUS))
self.add_property(
Property('total_phymem', _(u'Total physical memory'),
pretty_size(psutil.TOTAL_PHYMEM)))
self.add_property(
Property(
'disk_partitions', _(u'Disk partitions'), '; '.join([
'%s %s %s %s' % (partition.device, partition.mountpoint,
partition.fstype, partition.opts)
for partition in psutil.disk_partitions()
])))
try:
self.add_property(
Property('tesseract', _(u'tesseract version'),
pbs.tesseract('-v').stderr))
except pbs.CommandNotFound:
self.add_property(
Property('tesseract', _(u'tesseract version'),
_(u'not found')))
try:
self.add_property(
Property('unpaper', _(u'unpaper version'),
pbs.unpaper('-V').stdout))
except pbs.CommandNotFound:
self.add_property(
Property('unpaper', _(u'unpaper version'), _(u'not found')))
import psutil
import platform
# задача 4 - вывести диагностическую информацию рабочей
# машины - ЦПУ, оперативная память свободная/занятая,
# диски - свободно/занято, сетевые интерфейсы, тип и версия ОС
print(
'CPU: {0} CORES: {1} THREADS: {2} LOAD: {3} % FREQ_CUR: {4} MHz FREQ_MAX: {5} MHz FREQ_MIN: {6} MHz'
.format(
platform.processor(), # Тип проца
psutil.cpu_count(logical=False), # Количество ядер
psutil.cpu_count(), # Ядра(логические)
psutil.cpu_percent(interval=None), # Нагрузка в данный момент
int(psutil.cpu_freq()[0]), # Частота в данный момент
int(psutil.cpu_freq()[2]), # Максимальная частота
int(psutil.cpu_freq()[1])) # Минимальная
)
print(
'MEMORY ALL: {0} MB IN_USE: {1} MB FREE: {2} MB AVAILABLE: {3} MB'.format(
int(psutil.virtual_memory().total / 1024 / 1024), # Память вся
int(psutil.virtual_memory().used / 1024 / 1024), # Использованная
int(psutil.virtual_memory().free / 1024 / 1024), # Свободная
int(psutil.virtual_memory().available / 1024 /
1024)) # Всего доступно памяти
)
print('DISKS: ')
for part in psutil.disk_partitions():
print(
' DEV :{0:<15} MOUNT: {1:<30} fstype: {2:<10} USED: {3:<10} FREE: {4:<10} MB ALL: {5} MB'
.format(
# Starting system analysis
print "[!] ", "Checking your system *wait...\n\n"
now = datetime.now()
print "[-] Checking Start time is.. : ", now, "\n"
#import your system name and network ip addr
f0x_name = socket.gethostname()
f0x_ip = socket.gethostbyname(f0x_name)
print "컴퓨터 이름 : ", f0x_name
print "컴퓨터 Ip addr :", f0x_ip, "\n"
print "[+] ", "OS 종류: ", platform.system()
print "[+] ", "OS 상세정보: ", platform.platform()
print "[+] ", "OS 버전: ", platform.version()
print "[+] ", "프로세서: ", platform.processor()
print "[+] ", "CPU 수: ", multiprocessing.cpu_count(), "\n\n"
def initialize_openhardwaremonitor():
file = 'OpenHardwareMonitorLib.dll'
clr.AddReference(file)
from OpenHardwareMonitor import Hardware
handle = Hardware.Computer()
handle.MainboardEnabled = True
handle.CPUEnabled = True
handle.RAMEnabled = True
handle.GPUEnabled = True
handle.HDDEnabled = True
def checkproc():
ans = str(platform.processor())
return ans
def __init__(self):
self.msg = lcg.msg.msg('LCG Configuration')
# check operating system
# variables in this section
self.isWin32 = 0
self.isMacOS = 0
self.isLinux = 0
# checks
if sys.platform in [
'darwin',
]: self.isMacOS = 1
elif sys.platform in [
'linux',
'linux2',
]: self.isLinux = 1
elif sys.platform in [
'win32',
]: self.isWin32 = 1
# set lib path name
self.libpathname = ''
if self.isMacOS: self.libpathname = 'DYLD_LIBRARY_PATH'
elif self.isLinux: self.libpathname = 'LD_LIBRARY_PATH'
elif self.isWin32: self.libpathname = 'PATH'
# check processor type
self.processor = ''
self.architecture = ''
# checks
self.processor = platform.processor()
self.architecture = platform.architecture()
# check architecture
self.is32bit = 0
self.is64bit = 0
if platform.architecture()[0] == '32bit': self.is32bit = 1
if platform.architecture()[0] == '64bit': self.is64bit = 1
# check processor endianess
# variables in this section
self.isBigEndian = 0
self.isLittleEndian = 0
# checks
if sys.byteorder == 'big': self.isBigEndian = 1
elif sys.byteorder == 'little': self.isLittleEndian = 1
# check operating system version
# variables in this section
self.osMaxRelease = 0
self.osMajRelease = 0
self.osMinRelease = 0
self.osReleaseStr = ''
# checks
if self.isMacOS:
verList = map(lambda x: int(x), platform.release().split('.'))
if len(verList) > 2:
self.osMaxRelease = 10
self.osMajRelease = verList[0] - 4
self.osMinRelease = verList[1]
if self.osMaxRelease == 10:
if self.osMajRelease == 3: self.osReleaseStr = 'Panther'
elif self.osMajRelease == 4: self.osReleaseStr = 'Tiger'
elif self.osMajRelease == 5: self.osReleaseStr = 'Leopard'
elif self.osMajRelease == 6:
self.osReleaseStr = 'Snow Leopard'
else:
self.msg.error(
'Second number of os release no %s unknown' %
verList)
else:
self.msg.error('First number of os release no %s unknown' %
verList)
else:
self.msg.error(
'Trouble reading os relase, expected a list of min len 3, got'
% verList)
elif self.isLinux:
if os.path.isfile('/etc/issue'):
issue = open('/etc/issue', 'r')
firstl = issue.readline().split()
if ' '.join(firstl[:5]) == 'Scientific Linux CERN SLC release':
self.osReleaseStr = 'slc' + firstl[5].split('.')[0]
self.osMaxRelease = firstl[5].split('.')[0]
self.osMajRelease = firstl[5].split('.')[1]
issue.close()
elif self.isWin32:
pass
# check afs availability
# variables in this section
self.hasAFS = 0
self.p_afs = ''
if 1: # check afs availability
if self.isWin32:
if os.environ().has_key('AFS'):
self.p_afs = os.environ()['AFS']
self.msg.info(
'Found environment variable AFS, setting self.p_afs to %s'
% self.p_afs)
else:
self.p_afs = 'E:'
self.msg.warning(
'No environment variable AFS found, setting self.p_afs to %s'
% self.p_afs)
def build_extensions(self):
library_dirs = []
include_dirs = []
_add_directory(include_dirs, "src/libImaging")
pkg_config = None
if _cmd_exists('pkg-config'):
pkg_config = _pkg_config
#
# add configured kits
for root_name, lib_name in dict(
JPEG_ROOT="libjpeg",
JPEG2K_ROOT="libopenjp2",
TIFF_ROOT=("libtiff-5", "libtiff-4"),
ZLIB_ROOT="zlib",
FREETYPE_ROOT="freetype2",
LCMS_ROOT="lcms2",
IMAGEQUANT_ROOT="libimagequant").items():
root = globals()[root_name]
if root is None and pkg_config:
if isinstance(lib_name, tuple):
for lib_name2 in lib_name:
_dbg('Looking for `%s` using pkg-config.' % lib_name2)
root = pkg_config(lib_name2)
if root:
break
else:
_dbg('Looking for `%s` using pkg-config.' % lib_name)
root = pkg_config(lib_name)
if isinstance(root, tuple):
lib_root, include_root = root
else:
lib_root = include_root = root
_add_directory(library_dirs, lib_root)
_add_directory(include_dirs, include_root)
# respect CFLAGS/LDFLAGS
for k in ('CFLAGS', 'LDFLAGS'):
if k in os.environ:
for match in re.finditer(r'-I([^\s]+)', os.environ[k]):
_add_directory(include_dirs, match.group(1))
for match in re.finditer(r'-L([^\s]+)', os.environ[k]):
_add_directory(library_dirs, match.group(1))
# include, rpath, if set as environment variables:
for k in ('C_INCLUDE_PATH', 'CPATH', 'INCLUDE'):
if k in os.environ:
for d in os.environ[k].split(os.path.pathsep):
_add_directory(include_dirs, d)
for k in ('LD_RUN_PATH', 'LIBRARY_PATH', 'LIB'):
if k in os.environ:
for d in os.environ[k].split(os.path.pathsep):
_add_directory(library_dirs, d)
prefix = sysconfig.get_config_var("prefix")
if prefix:
_add_directory(library_dirs, os.path.join(prefix, "lib"))
_add_directory(include_dirs, os.path.join(prefix, "include"))
#
# add platform directories
if self.disable_platform_guessing:
pass
elif sys.platform == "cygwin":
# pythonX.Y.dll.a is in the /usr/lib/pythonX.Y/config directory
_add_directory(
library_dirs,
os.path.join("/usr/lib", "python%s" % sys.version[:3],
"config"))
elif sys.platform == "darwin":
# attempt to make sure we pick freetype2 over other versions
_add_directory(include_dirs, "/sw/include/freetype2")
_add_directory(include_dirs, "/sw/lib/freetype2/include")
# fink installation directories
_add_directory(library_dirs, "/sw/lib")
_add_directory(include_dirs, "/sw/include")
# darwin ports installation directories
_add_directory(library_dirs, "/opt/local/lib")
_add_directory(include_dirs, "/opt/local/include")
# if Homebrew is installed, use its lib and include directories
try:
prefix = subprocess.check_output(['brew', '--prefix'
]).strip().decode('latin1')
except Exception:
# Homebrew not installed
prefix = None
ft_prefix = None
if prefix:
# add Homebrew's include and lib directories
_add_directory(library_dirs, os.path.join(prefix, 'lib'))
_add_directory(include_dirs, os.path.join(prefix, 'include'))
ft_prefix = os.path.join(prefix, 'opt', 'freetype')
if ft_prefix and os.path.isdir(ft_prefix):
# freetype might not be linked into Homebrew's prefix
_add_directory(library_dirs, os.path.join(ft_prefix, 'lib'))
_add_directory(include_dirs,
os.path.join(ft_prefix, 'include'))
else:
# fall back to freetype from XQuartz if
# Homebrew's freetype is missing
_add_directory(library_dirs, "/usr/X11/lib")
_add_directory(include_dirs, "/usr/X11/include")
elif sys.platform.startswith("linux"):
arch_tp = (plat.processor(), plat.architecture()[0])
# This should be correct on debian derivatives.
if os.path.exists('/etc/debian_version'):
# If this doesn't work, don't just silently patch
# downstream because it's going to break when people
# try to build pillow from source instead of
# installing from the system packages.
self.add_multiarch_paths()
elif arch_tp == ("x86_64", "32bit"):
# Special Case: 32-bit build on 64-bit machine.
_add_directory(library_dirs, "/usr/lib/i386-linux-gnu")
else:
libdirs = {
'x86_64':
["/lib64", "/usr/lib64", "/usr/lib/x86_64-linux-gnu"],
'64bit':
["/lib64", "/usr/lib64", "/usr/lib/x86_64-linux-gnu"],
'i386': ["/usr/lib/i386-linux-gnu"],
'i686': ["/usr/lib/i386-linux-gnu"],
'32bit': ["/usr/lib/i386-linux-gnu"],
'aarch64': ["/usr/lib64", "/usr/lib/aarch64-linux-gnu"],
'arm': ["/usr/lib/arm-linux-gnueabi"],
'armv71': ["/usr/lib/arm-linux-gnueabi"],
'armv7l': ["/usr/lib"],
'ppc64': [
"/usr/lib64", "/usr/lib/ppc64-linux-gnu",
"/usr/lib/powerpc64-linux-gnu"
],
'ppc64le': ["/usr/lib64"],
'ppc':
["/usr/lib/ppc-linux-gnu", "/usr/lib/powerpc-linux-gnu"],
's390x': ["/usr/lib64", "/usr/lib/s390x-linux-gnu"],
's390': ["/usr/lib/s390-linux-gnu"],
}
for platform_ in arch_tp:
dirs = libdirs.get(platform_, None)
if not dirs:
continue
for path in dirs:
_add_directory(library_dirs, path)
break
else:
raise ValueError(
"Unable to identify Linux platform: `%s`" % platform_)
# termux support for android.
# system libraries (zlib) are installed in /system/lib
# headers are at $PREFIX/include
# user libs are at $PREFIX/lib
if os.environ.get('ANDROID_ROOT', None):
_add_directory(
library_dirs,
os.path.join(os.environ['ANDROID_ROOT'], 'lib'))
elif sys.platform.startswith("gnu"):
self.add_multiarch_paths()
elif sys.platform.startswith("freebsd"):
_add_directory(library_dirs, "/usr/local/lib")
_add_directory(include_dirs, "/usr/local/include")
elif sys.platform.startswith("netbsd"):
_add_directory(library_dirs, "/usr/pkg/lib")
_add_directory(include_dirs, "/usr/pkg/include")
elif sys.platform.startswith("sunos5"):
_add_directory(library_dirs, "/opt/local/lib")
_add_directory(include_dirs, "/opt/local/include")
# FIXME: check /opt/stuff directories here?
# standard locations
if not self.disable_platform_guessing:
_add_directory(library_dirs, "/usr/local/lib")
_add_directory(include_dirs, "/usr/local/include")
_add_directory(library_dirs, "/usr/lib")
_add_directory(include_dirs, "/usr/include")
# alpine, at least
_add_directory(library_dirs, "/lib")
# on Windows, look for the OpenJPEG libraries in the location that
# the official installer puts them
if sys.platform == "win32":
program_files = os.environ.get('ProgramFiles', '')
best_version = (0, 0)
best_path = None
for name in os.listdir(program_files):
if name.startswith('OpenJPEG '):
version = tuple(
int(x) for x in name[9:].strip().split('.'))
if version > best_version:
best_version = version
best_path = os.path.join(program_files, name)
if best_path:
_dbg('Adding %s to search list', best_path)
_add_directory(library_dirs, os.path.join(best_path, 'lib'))
_add_directory(include_dirs,
os.path.join(best_path, 'include'))
#
# insert new dirs *before* default libs, to avoid conflicts
# between Python PYD stub libs and real libraries
self.compiler.library_dirs = library_dirs + self.compiler.library_dirs
self.compiler.include_dirs = include_dirs + self.compiler.include_dirs
#
# look for available libraries
feature = self.feature
if feature.want('zlib'):
_dbg('Looking for zlib')
if _find_include_file(self, "zlib.h"):
if _find_library_file(self, "z"):
feature.zlib = "z"
elif (sys.platform == "win32"
and _find_library_file(self, "zlib")):
feature.zlib = "zlib" # alternative name
if feature.want('jpeg'):
_dbg('Looking for jpeg')
if _find_include_file(self, "jpeglib.h"):
if _find_library_file(self, "jpeg"):
feature.jpeg = "jpeg"
elif (sys.platform == "win32"
and _find_library_file(self, "libjpeg")):
feature.jpeg = "libjpeg" # alternative name
feature.openjpeg_version = None
if feature.want('jpeg2000'):
_dbg('Looking for jpeg2000')
best_version = None
best_path = None
# Find the best version
for directory in self.compiler.include_dirs:
_dbg('Checking for openjpeg-#.# in %s', directory)
try:
listdir = os.listdir(directory)
except Exception:
# WindowsError, FileNotFoundError
continue
for name in listdir:
if name.startswith('openjpeg-') and \
os.path.isfile(os.path.join(directory, name,
'openjpeg.h')):
_dbg('Found openjpeg.h in %s/%s', (directory, name))
version = tuple(int(x) for x in name[9:].split('.'))
if best_version is None or version > best_version:
best_version = version
best_path = os.path.join(directory, name)
_dbg('Best openjpeg version %s so far in %s',
(best_version, best_path))
if best_version and _find_library_file(self, 'openjp2'):
# Add the directory to the include path so we can include
# <openjpeg.h> rather than having to cope with the versioned
# include path
# FIXME (melvyn-sopacua):
# At this point it's possible that best_path is already in
# self.compiler.include_dirs. Should investigate how that is
# possible.
_add_directory(self.compiler.include_dirs, best_path, 0)
feature.jpeg2000 = 'openjp2'
feature.openjpeg_version = '.'.join(
str(x) for x in best_version)
if feature.want('imagequant'):
_dbg('Looking for imagequant')
if _find_include_file(self, 'libimagequant.h'):
if _find_library_file(self, "imagequant"):
feature.imagequant = "imagequant"
elif _find_library_file(self, "libimagequant"):
feature.imagequant = "libimagequant"
if feature.want('tiff'):
_dbg('Looking for tiff')
if _find_include_file(self, 'tiff.h'):
if _find_library_file(self, "tiff"):
feature.tiff = "tiff"
if sys.platform == "win32" and _find_library_file(
self, "libtiff"):
feature.tiff = "libtiff"
if (sys.platform == "darwin"
and _find_library_file(self, "libtiff")):
feature.tiff = "libtiff"
if feature.want('freetype'):
_dbg('Looking for freetype')
if _find_library_file(self, "freetype"):
# look for freetype2 include files
freetype_version = 0
for subdir in self.compiler.include_dirs:
_dbg('Checking for include file %s in %s',
("ft2build.h", subdir))
if os.path.isfile(os.path.join(subdir, "ft2build.h")):
_dbg('Found %s in %s', ("ft2build.h", subdir))
freetype_version = 21
subdir = os.path.join(subdir, "freetype2")
break
subdir = os.path.join(subdir, "freetype2")
_dbg('Checking for include file %s in %s',
("ft2build.h", subdir))
if os.path.isfile(os.path.join(subdir, "ft2build.h")):
_dbg('Found %s in %s', ("ft2build.h", subdir))
freetype_version = 21
break
if freetype_version:
feature.freetype = "freetype"
feature.freetype_version = freetype_version
if subdir:
_add_directory(self.compiler.include_dirs, subdir, 0)
if feature.want('lcms'):
_dbg('Looking for lcms')
if _find_include_file(self, "lcms2.h"):
if _find_library_file(self, "lcms2"):
feature.lcms = "lcms2"
elif _find_library_file(self, "lcms2_static"):
# alternate Windows name.
feature.lcms = "lcms2_static"
if feature.want('webp'):
_dbg('Looking for webp')
if (_find_include_file(self, "webp/encode.h")
and _find_include_file(self, "webp/decode.h")):
# In Google's precompiled zip it is call "libwebp":
if _find_library_file(self, "webp"):
feature.webp = "webp"
elif _find_library_file(self, "libwebp"):
feature.webp = "libwebp"
if feature.want('webpmux'):
_dbg('Looking for webpmux')
if (_find_include_file(self, "webp/mux.h")
and _find_include_file(self, "webp/demux.h")):
if (_find_library_file(self, "webpmux")
and _find_library_file(self, "webpdemux")):
feature.webpmux = "webpmux"
if (_find_library_file(self, "libwebpmux")
and _find_library_file(self, "libwebpdemux")):
feature.webpmux = "libwebpmux"
for f in feature:
if not getattr(feature, f) and feature.require(f):
if f in ('jpeg', 'zlib'):
raise RequiredDependencyException(f)
raise DependencyException(f)
#
# core library
files = ["src/_imaging.c"]
for src_file in _IMAGING:
files.append("src/" + src_file + ".c")
for src_file in _LIB_IMAGING:
files.append(os.path.join("src/libImaging", src_file + ".c"))
libs = []
defs = []
if feature.jpeg:
libs.append(feature.jpeg)
defs.append(("HAVE_LIBJPEG", None))
if feature.jpeg2000:
libs.append(feature.jpeg2000)
defs.append(("HAVE_OPENJPEG", None))
if sys.platform == "win32":
defs.append(("OPJ_STATIC", None))
if feature.zlib:
libs.append(feature.zlib)
defs.append(("HAVE_LIBZ", None))
if feature.imagequant:
libs.append(feature.imagequant)
defs.append(("HAVE_LIBIMAGEQUANT", None))
if feature.tiff:
libs.append(feature.tiff)
defs.append(("HAVE_LIBTIFF", None))
if sys.platform == "win32":
libs.extend(["kernel32", "user32", "gdi32"])
if struct.unpack("h", "\0\1".encode('ascii'))[0] == 1:
defs.append(("WORDS_BIGENDIAN", None))
if sys.platform == "win32" and not (PLATFORM_PYPY or PLATFORM_MINGW):
defs.append(("PILLOW_VERSION", '"\\"%s\\""' % PILLOW_VERSION))
else:
defs.append(("PILLOW_VERSION", '"%s"' % PILLOW_VERSION))
exts = [(Extension("PIL._imaging",
files,
libraries=libs,
define_macros=defs))]
#
# additional libraries
if feature.freetype:
libs = ["freetype"]
defs = []
exts.append(
Extension("PIL._imagingft", ["src/_imagingft.c"],
libraries=libs,
define_macros=defs))
if feature.lcms:
extra = []
if sys.platform == "win32":
extra.extend(["user32", "gdi32"])
exts.append(
Extension("PIL._imagingcms", ["src/_imagingcms.c"],
libraries=[feature.lcms] + extra))
if feature.webp:
libs = [feature.webp]
defs = []
if feature.webpmux:
defs.append(("HAVE_WEBPMUX", None))
libs.append(feature.webpmux)
libs.append(feature.webpmux.replace('pmux', 'pdemux'))
exts.append(
Extension("PIL._webp", ["src/_webp.c"],
libraries=libs,
define_macros=defs))
tk_libs = ['psapi'] if sys.platform == 'win32' else []
exts.append(
Extension("PIL._imagingtk",
["src/_imagingtk.c", "src/Tk/tkImaging.c"],
include_dirs=['src/Tk'],
libraries=tk_libs))
exts.append(Extension("PIL._imagingmath", ["src/_imagingmath.c"]))
exts.append(Extension("PIL._imagingmorph", ["src/_imagingmorph.c"]))
self.extensions[:] = exts
build_ext.build_extensions(self)
#
# sanity checks
self.summary_report(feature)
class Hpl(AutotoolsPackage):
"""HPL is a software package that solves a (random) dense linear system
in double precision (64 bits) arithmetic on distributed-memory computers.
It can thus be regarded as a portable as well as freely available
implementation of the High Performance Computing Linpack Benchmark."""
homepage = "https://www.netlib.org/benchmark/hpl/"
url = "https://www.netlib.org/benchmark/hpl/hpl-2.2.tar.gz"
# Note: HPL uses autotools starting with 2.3
version('2.3',
sha256=
'32c5c17d22330e6f2337b681aded51637fb6008d3f0eb7c277b163fadd612830')
version('2.2',
sha256=
'ac7534163a09e21a5fa763e4e16dfc119bc84043f6e6a807aba666518f8df440')
variant('openmp', default=False, description='Enable OpenMP support')
depends_on('[email protected]:')
depends_on('blas')
# 2.3 adds support for openmpi 4
conflicts('^[email protected]:', when='@:2.2')
parallel = False
arch = '{0}-{1}'.format(platform.system(), platform.processor())
build_targets = ['arch={0}'.format(arch)]
@when('@:2.2')
def autoreconf(self, spec, prefix):
# Prevent sanity check from killing the build
touch('configure')
@when('@:2.2')
def configure(self, spec, prefix):
# List of configuration options
# Order is important
config = []
# OpenMP support
if '+openmp' in spec:
config.append('OMP_DEFS = {0}'.format(
self.compiler.openmp_flag))
config.extend([
# Shell
'SHELL = /bin/sh',
'CD = cd',
'CP = cp',
'LN_S = ln -fs',
'MKDIR = mkdir -p',
'RM = /bin/rm -f',
'TOUCH = touch',
# Platform identifier
'ARCH = {0}'.format(self.arch),
# HPL Directory Structure / HPL library
'TOPdir = {0}'.format(os.getcwd()),
'INCdir = $(TOPdir)/include',
'BINdir = $(TOPdir)/bin/$(ARCH)',
'LIBdir = $(TOPdir)/lib/$(ARCH)',
'HPLlib = $(LIBdir)/libhpl.a',
# Message Passing library (MPI)
'MPinc = {0}'.format(spec['mpi'].prefix.include),
'MPlib = -L{0}'.format(spec['mpi'].prefix.lib),
# Linear Algebra library (BLAS or VSIPL)
'LAinc = {0}'.format(spec['blas'].prefix.include),
'LAlib = {0}'.format(spec['blas'].libs.joined()),
# F77 / C interface
'F2CDEFS = -DAdd_ -DF77_INTEGER=int -DStringSunStyle',
# HPL includes / libraries / specifics
'HPL_INCLUDES = -I$(INCdir) -I$(INCdir)/$(ARCH) ' +
'-I$(LAinc) -I$(MPinc)',
'HPL_LIBS = $(HPLlib) $(LAlib) $(MPlib)',
'HPL_OPTS = -DHPL_DETAILED_TIMING -DHPL_PROGRESS_REPORT',
'HPL_DEFS = $(F2CDEFS) $(HPL_OPTS) $(HPL_INCLUDES)',
# Compilers / linkers - Optimization flags
'CC = {0}'.format(spec['mpi'].mpicc),
'CCNOOPT = $(HPL_DEFS)',
'CCFLAGS = $(HPL_DEFS) -O3',
'LINKER = $(CC)',
'LINKFLAGS = $(CCFLAGS) $(OMP_DEFS)',
'ARCHIVER = ar',
'ARFLAGS = r',
'RANLIB = echo'
])
# Write configuration options to include file
with open('Make.{0}'.format(self.arch), 'w') as makefile:
for var in config:
makefile.write('{0}\n'.format(var))
@when('@2.3:')
def configure_args(self):
filter_file(r"^libs10=.*",
"libs10=%s" % self.spec["blas"].libs.ld_flags, "configure")
if '+openmp' in self.spec:
config = ['CFLAGS=-O3 ' + self.compiler.openmp_flag]
else:
config = ['CFLAGS=-O3']
if (self.spec.satisfies('^intel-mkl')
or self.spec.satisfies('^intel-oneapi-mkl')
or self.spec.satisfies('^intel-parallel-studio+mkl')):
config.append('LDFLAGS={0}'.format(
self.spec['blas'].libs.ld_flags))
return config
@when('@:2.2')
def install(self, spec, prefix):
# Manual installation
install_tree(join_path('bin', self.arch), prefix.bin)
install_tree(join_path('lib', self.arch), prefix.lib)
install_tree(join_path('include', self.arch), prefix.include)
install_tree('man', prefix.man)
@run_after('install')
def copy_dat(self):
if self.spec.satisfies('@2.3:'):
# The pre-2.3 makefile would include a default HPL.dat config
# file in the bin directory
install('./testing/ptest/HPL.dat',
join_path(self.prefix.bin, 'HPL.dat'))
def build_extensions(self):
global TCL_ROOT
library_dirs = []
include_dirs = []
_add_directory(include_dirs, "libImaging")
#
# add configured kits
for root in (TCL_ROOT, JPEG_ROOT, TIFF_ROOT, ZLIB_ROOT, FREETYPE_ROOT,
LCMS_ROOT):
if isinstance(root, type(())):
lib_root, include_root = root
else:
lib_root = include_root = root
_add_directory(library_dirs, lib_root)
_add_directory(include_dirs, include_root)
#
# add platform directories
if sys.platform == "cygwin":
# pythonX.Y.dll.a is in the /usr/lib/pythonX.Y/config directory
_add_directory(
library_dirs,
os.path.join("/usr/lib", "python%s" % sys.version[:3],
"config"))
elif sys.platform == "darwin":
# attempt to make sure we pick freetype2 over other versions
_add_directory(include_dirs, "/sw/include/freetype2")
_add_directory(include_dirs, "/sw/lib/freetype2/include")
# fink installation directories
_add_directory(library_dirs, "/sw/lib")
_add_directory(include_dirs, "/sw/include")
# darwin ports installation directories
_add_directory(library_dirs, "/opt/local/lib")
_add_directory(include_dirs, "/opt/local/include")
# freetype2 ships with X11
_add_directory(library_dirs, "/usr/X11/lib")
_add_directory(include_dirs, "/usr/X11/include")
elif sys.platform.startswith("linux"):
for platform_ in (plat.processor(), plat.architecture()[0]):
if not platform_:
continue
if platform_ in ["x86_64", "64bit"]:
_add_directory(library_dirs, "/lib64")
_add_directory(library_dirs, "/usr/lib64")
_add_directory(library_dirs, "/usr/lib/x86_64-linux-gnu")
break
elif platform_ in ["i386", "i686", "32bit"]:
_add_directory(library_dirs, "/usr/lib/i386-linux-gnu")
break
else:
raise ValueError("Unable to identify Linux platform: `%s`" %
platform_)
# XXX Kludge. Above /\ we brute force support multiarch. Here we
# try Barry's more general approach. Afterward, something should
# work ;-)
self.add_multiarch_paths()
_add_directory(library_dirs, "/usr/local/lib")
# FIXME: check /opt/stuff directories here?
# include, rpath, if set as environment variables:
if os.environ.get('C_INCLUDE_PATH'):
_add_directory(include_dirs, os.environ.get('C_INCLUDE_PATH'))
if os.environ.get('LD_RUN_PATH'):
_add_directory(library_dirs, os.environ.get('LD_RUN_PATH'))
prefix = sysconfig.get_config_var("prefix")
if prefix:
_add_directory(library_dirs, os.path.join(prefix, "lib"))
_add_directory(include_dirs, os.path.join(prefix, "include"))
#
# locate tkinter libraries
if _tkinter:
TCL_VERSION = _tkinter.TCL_VERSION[:3]
if _tkinter and not TCL_ROOT:
# we have Tkinter but the TCL_ROOT variable was not set;
# try to locate appropriate Tcl/Tk libraries
PYVERSION = sys.version[0] + sys.version[2]
TCLVERSION = TCL_VERSION[0] + TCL_VERSION[2]
roots = [
# common installation directories, mostly for Windows
# (for Unix-style platforms, we'll check in well-known
# locations later)
os.path.join("/py" + PYVERSION, "Tcl"),
os.path.join("/python" + PYVERSION, "Tcl"),
"/Tcl",
"/Tcl" + TCLVERSION,
"/Tcl" + TCL_VERSION,
os.path.join(os.environ.get("ProgramFiles", ""), "Tcl"),
]
for TCL_ROOT in roots:
TCL_ROOT = os.path.abspath(TCL_ROOT)
if os.path.isfile(os.path.join(TCL_ROOT, "include", "tk.h")):
# FIXME: use distutils logging (?)
print("--- using Tcl/Tk libraries at", TCL_ROOT)
print("--- using Tcl/Tk version", TCL_VERSION)
TCL_ROOT = _lib_include(TCL_ROOT)
break
else:
TCL_ROOT = None
# add standard directories
# look for tcl specific subdirectory (e.g debian)
if _tkinter:
tcl_dir = "/usr/include/tcl" + TCL_VERSION
if os.path.isfile(os.path.join(tcl_dir, "tk.h")):
_add_directory(include_dirs, tcl_dir)
# standard locations
_add_directory(library_dirs, "/usr/local/lib")
_add_directory(include_dirs, "/usr/local/include")
_add_directory(library_dirs, "/usr/lib")
_add_directory(include_dirs, "/usr/include")
#
# insert new dirs *before* default libs, to avoid conflicts
# between Python PYD stub libs and real libraries
self.compiler.library_dirs = library_dirs + self.compiler.library_dirs
self.compiler.include_dirs = include_dirs + self.compiler.include_dirs
#
# look for available libraries
feature = self.feature
if feature.want('zlib'):
if _find_include_file(self, "zlib.h"):
if _find_library_file(self, "z"):
feature.zlib = "z"
elif sys.platform == "win32" and _find_library_file(
self, "zlib"):
feature.zlib = "zlib" # alternative name
if feature.want('jpeg'):
if _find_include_file(self, "jpeglib.h"):
if _find_library_file(self, "jpeg"):
feature.jpeg = "jpeg"
elif (sys.platform == "win32"
and _find_library_file(self, "libjpeg")):
feature.jpeg = "libjpeg" # alternative name
if feature.want('tiff'):
if _find_library_file(self, "tiff"):
feature.tiff = "tiff"
if sys.platform == "win32" and _find_library_file(self, "libtiff"):
feature.tiff = "libtiff"
if sys.platform == "darwin" and _find_library_file(
self, "libtiff"):
feature.tiff = "libtiff"
if feature.want('freetype'):
if _find_library_file(self, "freetype"):
# look for freetype2 include files
freetype_version = 0
for dir in self.compiler.include_dirs:
if os.path.isfile(os.path.join(dir, "ft2build.h")):
freetype_version = 21
dir = os.path.join(dir, "freetype2")
break
dir = os.path.join(dir, "freetype2")
if os.path.isfile(os.path.join(dir, "ft2build.h")):
freetype_version = 21
break
if os.path.isdir(os.path.join(dir, "freetype")):
freetype_version = 20
break
if freetype_version:
feature.freetype = "freetype"
feature.freetype_version = freetype_version
if dir:
_add_directory(self.compiler.include_dirs, dir, 0)
if feature.want('lcms'):
if _find_include_file(self, "lcms.h"):
if _find_library_file(self, "lcms"):
feature.lcms = "lcms"
if _tkinter and _find_include_file(self, "tk.h"):
# the library names may vary somewhat (e.g. tcl84 or tcl8.4)
version = TCL_VERSION[0] + TCL_VERSION[2]
if feature.want('tcl'):
if _find_library_file(self, "tcl" + version):
feature.tcl = "tcl" + version
elif _find_library_file(self, "tcl" + TCL_VERSION):
feature.tcl = "tcl" + TCL_VERSION
if feature.want('tk'):
if _find_library_file(self, "tk" + version):
feature.tk = "tk" + version
elif _find_library_file(self, "tk" + TCL_VERSION):
feature.tk = "tk" + TCL_VERSION
if feature.want('webp'):
if (_find_include_file(self, "webp/encode.h")
and _find_include_file(self, "webp/decode.h")):
if _find_library_file(
self, "webp"
): # in googles precompiled zip it is call "libwebp"
feature.webp = "webp"
if feature.want('webpmux'):
if (_find_include_file(self, "webp/mux.h")
and _find_include_file(self, "webp/demux.h")):
if _find_library_file(self, "webpmux") and _find_library_file(
self, "webpdemux"):
feature.webpmux = "webpmux"
for f in feature:
if not getattr(feature, f) and feature.require(f):
raise ValueError(
'--enable-%s requested but %s not found, aborting.' %
(f, f))
#
# core library
files = ["_imaging.c"]
for file in _IMAGING:
files.append(file + ".c")
for file in _LIB_IMAGING:
files.append(os.path.join("libImaging", file + ".c"))
libs = []
defs = []
if feature.jpeg:
libs.append(feature.jpeg)
defs.append(("HAVE_LIBJPEG", None))
if feature.zlib:
libs.append(feature.zlib)
defs.append(("HAVE_LIBZ", None))
if feature.tiff:
libs.append(feature.tiff)
defs.append(("HAVE_LIBTIFF", None))
if sys.platform == "win32":
libs.extend(["kernel32", "user32", "gdi32"])
if struct.unpack("h", "\0\1".encode('ascii'))[0] == 1:
defs.append(("WORDS_BIGENDIAN", None))
exts = [(Extension("PIL._imaging",
files,
libraries=libs,
define_macros=defs))]
#
# additional libraries
if feature.freetype:
defs = []
if feature.freetype_version == 20:
defs.append(("USE_FREETYPE_2_0", None))
exts.append(
Extension("PIL._imagingft", ["_imagingft.c"],
libraries=["freetype"],
define_macros=defs))
if os.path.isfile("_imagingtiff.c") and feature.tiff:
exts.append(
Extension("PIL._imagingtiff", ["_imagingtiff.c"],
libraries=["tiff"]))
if os.path.isfile("_imagingcms.c") and feature.lcms:
extra = []
if sys.platform == "win32":
extra.extend(["user32", "gdi32"])
exts.append(
Extension("PIL._imagingcms", ["_imagingcms.c"],
libraries=["lcms"] + extra))
if os.path.isfile("_webp.c") and feature.webp:
libs = ["webp"]
defs = []
if feature.webpmux:
defs.append(("HAVE_WEBPMUX", None))
libs.append("webpmux")
libs.append("webpdemux")
exts.append(
Extension("PIL._webp", ["_webp.c"],
libraries=libs,
define_macros=defs))
if sys.platform == "darwin":
# locate Tcl/Tk frameworks
frameworks = []
framework_roots = [
"/Library/Frameworks", "/System/Library/Frameworks"
]
for root in framework_roots:
if (os.path.exists(os.path.join(root, "Tcl.framework")) and
os.path.exists(os.path.join(root, "Tk.framework"))):
print("--- using frameworks at %s" % root)
frameworks = ["-framework", "Tcl", "-framework", "Tk"]
dir = os.path.join(root, "Tcl.framework", "Headers")
_add_directory(self.compiler.include_dirs, dir, 0)
dir = os.path.join(root, "Tk.framework", "Headers")
_add_directory(self.compiler.include_dirs, dir, 1)
break
if frameworks:
exts.append(
Extension("PIL._imagingtk",
["_imagingtk.c", "Tk/tkImaging.c"],
extra_compile_args=frameworks,
extra_link_args=frameworks))
feature.tcl = feature.tk = 1 # mark as present
elif feature.tcl and feature.tk:
exts.append(
Extension("PIL._imagingtk", ["_imagingtk.c", "Tk/tkImaging.c"],
libraries=[feature.tcl, feature.tk]))
if os.path.isfile("_imagingmath.c"):
exts.append(Extension("PIL._imagingmath", ["_imagingmath.c"]))
self.extensions[:] = exts
build_ext.build_extensions(self)
#
# sanity and security checks
unsafe_zlib = None
if feature.zlib:
unsafe_zlib = self.check_zlib_version(self.compiler.include_dirs)
self.summary_report(feature, unsafe_zlib)
""" Test QiBuild Clean """
from __future__ import absolute_import
from __future__ import unicode_literals
from __future__ import print_function
import os
import platform
import py
import qisys.sh
import qibuild.config
import qibuild.profile
from qibuild.test.conftest import TestBuildWorkTree
TARGET = "{}-{}".format(platform.system().lower(),
platform.processor().lower())
def test_clean_build_dir(qibuild_action):
""" Test Clean Build Dir """
world_proj = qibuild_action.add_test_project("world")
qibuild_action("configure", "world")
qibuild_action("clean", "world")
assert os.path.exists(world_proj.build_directory)
qibuild_action("clean", "-f", "world")
assert not os.path.exists(world_proj.build_directory)
def test_only_clean_one_build_dir(qibuild_action):
""" Test Only Clean One Build Dir """
qibuild.config.add_build_config("foo")
def CheckArchitecture(self):
# Fill with Python info
import sys
self.archi_info.python_version = sys.version.replace('\n', '')
# Fill with Platform info
import platform
self.archi_info.platform = platform.system()
self.archi_info.release = platform.release()
# Fill with number of cores
import multiprocessing
self.archi_info.ncores = multiprocessing.cpu_count()
# Is Mac
platform_text = "Platform: " + self.archi_info.platform + " " + self.archi_info.release + " "
if self.archi_info.platform.lower() in ['darwin', 'mac', 'macosx']:
self.archi_info.isMac = True
platform_text += '\x1b[32m' + '[MAC/OSX mode]' + '\x1b[0m'
else:
self.archi_info.isMac = False
platform_text += '\x1b[32m' + '[Linux mode]' + '\x1b[0m'
self.logger.info(platform_text)
# Info for debug mode
if self.debug:
# Machine general
import platform
self.logger.debug("")
self.logger.debug("Machine - Cross platform information")
self.logger.debug(
StringTools.Left(" Machine type: ", 28) +
str(platform.machine()))
self.logger.debug(
StringTools.Left(" Processor name: ", 28) +
str(platform.processor()))
self.logger.debug(
StringTools.Left(" Platform: ", 28) +
str(platform.platform()))
self.logger.debug(
StringTools.Left(" Platform release: ", 28) +
str(platform.release()))
self.logger.debug(
StringTools.Left(" System: ", 28) +
str(platform.system()))
self.logger.debug(
StringTools.Left(" Node: ", 28) +
str(platform.node()))
self.logger.debug(
StringTools.Left(" Number of cores: ", 28) +
str(self.archi_info.ncores))
self.logger.debug("")
# Machine OS
self.logger.debug("Machine - OS-specific information")
try:
tmp = platform.java_ver()
except:
tmp = ''
self.logger.debug(
StringTools.Left(" Java version: ", 28) + str(tmp))
try:
tmp = platform.win32_ver()
except:
tmp = ''
self.logger.debug(
StringTools.Left(" Windows version: ", 28) + str(tmp))
try:
tmp = platform.mac_ver()
except:
tmp = ''
self.logger.debug(
StringTools.Left(" Mac Os version: ", 28) + str(tmp))
try:
tmp = platform.dist()
except:
tmp = ''
self.logger.debug(
StringTools.Left(" Unix distribution:", 28) +
str(platform.platform()))
self.logger.debug("")
return True
#!/bin/env python #!-*- coding:utf-8 -*- import platform #파이썬 코드 실행하는 운영체제 환경정보 제공 모듈 import multiprocessing #CPU 갯수 카운트 모듈 print(u"운영체제:"), platform.system() print(u"운영체제의 상세정보:"), platform.platform() print(u"운영체제 버전:"), platform.version() print(u"프로세서정보:"), platform.processor() print(u"CPU 수:"), multiprocessing.cpu_count()
#!/usr/bin/env python """ CGI-Tools Python Package Copyright (C) 2016 Assaf Gordon ([email protected]) License: BSD (See LICENSE file) """ from jinja2 import Template import platform sysdata = [ platform.machine(), platform.node(), platform.processor(), platform.system() ] pydata = [platform.python_implementation(), platform.python_version()] print "Content-Type: text/html" print # blank line, end of headers # Generate response HTML using Jinja2 Templating system html_tmpl = """ <html> <head> Hello from Python CGI Script <br/> <br/> System Data: <code>{{ system_data }}</code> <br/>
and limitations under the License.
@python_version: 3.5
===============================================================================
"""
import os
import platform
import multiprocessing
# Cluto binary
CLUTO_VCLUSTER_BINARY = os.path.join(os.getcwd(),
"bin",
"cluto-2.1.2",
platform.system()+"-"+platform.processor(),
"vcluster")
# Maximum CPU cores on a node
CPU_CORE = multiprocessing.cpu_count()
# Source data options
SOURCE_DATASET = os.path.join(os.getcwd(), "data", "source", "Tipster")
SAMPLED_DATA_PATH = os.path.join(os.getcwd(), "output", "sample")
TRAINING_DATA = os.path.join(SAMPLED_DATA_PATH, "train")
TESTING_DATA = os.path.join(SAMPLED_DATA_PATH, "test")
# Benchmark data options
def processor():
name = platform.processor()
return name
def main():
usage = "usage: %prog [-h|--help] [options]"
parser = OptionParser(usage=usage)
parser.add_option("-t",
"--throughput",
action="store_true",
dest="throughput",
default=False,
help="run throughput tests")
parser.add_option("-l",
"--latency",
action="store_true",
dest="latency",
default=False,
help="run latency tests")
parser.add_option("-b",
"--bandwidth",
action="store_true",
dest="bandwidth",
default=False,
help="run I/O bandwidth tests")
parser.add_option("-i",
"--interval",
action="store",
type="int",
dest="check_interval",
default=None,
help="sys.setcheckinterval() value "
"(Python 3.8 and older)")
parser.add_option("-I",
"--switch-interval",
action="store",
type="float",
dest="switch_interval",
default=None,
help="sys.setswitchinterval() value "
"(Python 3.2 and newer)")
parser.add_option("-n",
"--num-threads",
action="store",
type="int",
dest="nthreads",
default=4,
help="max number of threads in tests")
# Hidden option to run the pinging and bandwidth clients
parser.add_option("",
"--latclient",
action="store",
dest="latclient",
default=None,
help=SUPPRESS_HELP)
parser.add_option("",
"--bwclient",
action="store",
dest="bwclient",
default=None,
help=SUPPRESS_HELP)
options, args = parser.parse_args()
if args:
parser.error("unexpected arguments")
if options.latclient:
kwargs = eval(options.latclient)
latency_client(**kwargs)
return
if options.bwclient:
kwargs = eval(options.bwclient)
bandwidth_client(**kwargs)
return
if not options.throughput and not options.latency and not options.bandwidth:
options.throughput = options.latency = options.bandwidth = True
if options.check_interval:
sys.setcheckinterval(options.check_interval)
if options.switch_interval:
sys.setswitchinterval(options.switch_interval)
print("== %s %s (%s) ==" % (
platform.python_implementation(),
platform.python_version(),
platform.python_build()[0],
))
# Processor identification often has repeated spaces
cpu = ' '.join(platform.processor().split())
print("== %s %s on '%s' ==" % (
platform.machine(),
platform.system(),
cpu,
))
print()
if options.throughput:
print("--- Throughput ---")
print()
run_throughput_tests(options.nthreads)
if options.latency:
print("--- Latency ---")
print()
run_latency_tests(options.nthreads)
if options.bandwidth:
print("--- I/O bandwidth ---")
print()
run_bandwidth_tests(options.nthreads)
group = os.getgroups()
where = os.getcwd()
now = time.time()
means = time.ctime(now)
print ("User number",unumber)
print ("Process ID",pnumber)
print ("Login Name", login)
print ("Current Directory",where)
print ("Group", group)
print ("Name: " +socket.gethostname( ))
print ("FQDN: " +socket.getfqdn())
print ("System Platform: "+sys.platform)
print ("Node " +platform.node())
print ("Platform: "+platform.platform())
print ("System OS: "+platform.system())
print ("Release: " +platform.release())
print ("Version: " +platform.version())
print ("Python Version: " +platform.python_version())
print ("MacOS Version: " +platform.mac_ver()[0])
print ("Mac Address: " ,hex(mac))
# displaying platform architecture
print('Platform architecture:', platform.architecture())
# displaying platform processor
print('Platform processor:', platform.processor())
# displaying machine type
print('Machine type:', platform.machine())
# displaying system network name
print("System's network name:", platform.node())
def processor():
return platform.processor()
async def stats(self, ctx):
"""Posts bot stats."""
oe = "<:wonline:544126607443492895>"
ie = "<:widle:544126607669854219>"
de = "<:wdnd:544126607485304843>"
ge = "<:woffline:544126607711797253>"
cmd = r'git show -s HEAD~3..HEAD --format="[{}](https://github.com/JonnyBoy2000/Kira-Miki/commit/%H) %s (%cr)"'
if os.name == 'posix':
cmd = cmd.format(r'\`%h\`')
else:
cmd = cmd.format(r'`%h`')
try:
revision = os.popen(cmd).read().strip()
except OSError:
revision = 'Could not fetch due to memory error. Sorry.'
currentOS = platform.platform()
cpuUsage = psutil.cpu_percent(interval=1)
cpuThred = os.cpu_count()
pythonMajor = sys.version_info.major
pythonMinor = sys.version_info.minor
pythonMicro = sys.version_info.micro
pythonRelease = sys.version_info.releaselevel
pyBit = struct.calcsize("P") * 8
threadString = 'thread'
if not cpuThred == 1:
threadString += 's'
memStats = psutil.virtual_memory()
memUsed = memStats.used
memTotal = memStats.total
processor = platform.processor()
memUsedGB = "{0:.1f}".format(((memUsed / 1024) / 1024) / 1024)
memTotalGB = "{0:.1f}".format(((memTotal / 1024) / 1024) / 1024)
memPerc = str(((memTotal / 1024) / 1024) / 1024 /
((memUsed / 1024) / 1024) / 1024).split('.')[0]
process = subprocess.Popen(['git', 'rev-parse', '--short', 'HEAD'],
shell=False,
stdout=subprocess.PIPE)
git_head_hash = process.communicate()[0].strip()
dev = f"**Name:** {self.bot.get_user(170619078401196032)}\n**ID:** {self.bot.get_user(170619078401196032).id}"
online = len([
e.name for e in self.bot.get_all_members()
if e.status == discord.Status.online
])
idle = len([
e.name for e in self.bot.get_all_members()
if e.status == discord.Status.idle
])
dnd = len([
e.name for e in self.bot.get_all_members()
if e.status == discord.Status.dnd
])
offline = len([
e.name for e in self.bot.get_all_members()
if e.status == discord.Status.offline
])
used = humanize.naturalsize(self.bot.lavalink.stats.memory.used)
free = humanize.naturalsize(self.bot.lavalink.stats.memory.free)
memory = f"**Used:** {used}\n"
memory += f"**Free:** {free}\n"
cpu = f"**Cores:** {self.bot.lavalink.stats.cpu.cores}\n"
cpu += '**Cpu:** {}% of {} ({} {})\n'.format(cpuUsage, processor,
cpuThred, threadString)
cpu += '**Ram:** {} ({}%) of {}GB used\n'.format(
memUsedGB, memPerc, memTotalGB)
lava = f"**Launched:** {humanize.naturaltime(datetime.datetime.utcnow() - datetime.timedelta(milliseconds=self.bot.lavalink.stats.uptime))}\n"
lava += f"**Kira Players:** `{len(self.bot.lavalink.players._players)}` players are distributed.\n"
lava += f"**Lavalink Cpu Load:** {round(self.bot.lavalink.stats.cpu.lavalink_load * 100)}%\n"
basic = '**OS:** {}\n'.format(currentOS)
basic += '**Hostname:** {}\n'.format(platform.node())
basic += '**Language:** Python {}.{}.{} {} ({} bit)\n'.format(
pythonMajor, pythonMinor, pythonMicro, pythonRelease, pyBit)
basic += '**Commit:** {}\n'.format(git_head_hash.decode("utf-8"))
basic += f"**Bot Uptime:** {self.get_bot_uptime(brief=True)}"
members = f"{oe} {online} | "
members += f"{ie} {idle}\n"
members += f"{de} {dnd} | "
members += f"{ge} {offline}"
guilds = len(self.bot.guilds)
e = discord.Embed()
e.colour = 0x36393E
e.set_thumbnail(url=self.bot.user.avatar_url)
e.add_field(name="Basic:", value=basic)
e.add_field(name="Dev:", value=dev)
e.add_field(name="Guilds:", value=guilds)
e.add_field(name="Members:", value=members)
e.add_field(name="Lavalink:", value=lava)
e.add_field(name="Memory:", value=memory)
e.add_field(name="CPU | RAM:", value=cpu)
e.add_field(name="Latest Changes:", value=revision)
await ctx.send(embed=e)
def get_system_details(backends=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__,
'backends':
OrderedDict()
}
if backends:
from . import highlevel
for backend in highlevel.list_backends():
if backend.startswith('pyvisa-'):
backend = backend[7:]
try:
cls = highlevel.get_wrapper_class(backend)
except Exception as e:
d['backends'][backend] = [
'Could not instantiate backend',
'-> %s' % str(e)
]
continue
try:
d['backends'][backend] = cls.get_debug_info()
except Exception as e:
d['backends'][backend] = [
'Could not obtain debug info',
'-> %s' % str(e)
]
return d
def __init__(self):
"""
Método construtor.
"""
self.__shell = Shell(AcaoQuandoOcorrerErro.REPETIR_E_IGNORAR, 10)
self.__arquitetura = platform.processor()
def processor_detect():
pi = pi_version(processor=True)
if pi is None: return platform.processor()
init_log(0) # initialize logging service
INSTALL_PROFILE = None
try:
try:
INITSCR = setup_curses()
WIN_SIZE_Y, WIN_SIZE_X = INITSCR.getmaxyx()
if WIN_SIZE_Y < 24 or WIN_SIZE_X < 80:
MSG = _(" Terminal too small. Min size is 80x24."
" Current size is %(x)ix%(y)i.") % \
{'x': WIN_SIZE_X, 'y': WIN_SIZE_Y}
exit_text_installer(errcode=MSG)
INSTALL_PROFILE = InstallProfile()
INSTALL_PROFILE.log_location = OPTIONS.logname
INSTALL_PROFILE.log_final = LOG_LOCATION_FINAL
INSTALL_PROFILE.no_install_mode = OPTIONS.no_install
if platform.processor() == "i386":
INSTALL_PROFILE.is_x86 = True
else:
INSTALL_PROFILE.is_x86 = False
SCREEN_LIST = ScreenList()
MAIN_WIN = MainWindow(INITSCR,
SCREEN_LIST,
force_bw=OPTIONS.force_bw)
SCREEN_LIST.help = HelpScreen(MAIN_WIN)
WIN_LIST = make_screen_list(MAIN_WIN)
SCREEN_LIST.screen_list = WIN_LIST
SCREEN = SCREEN_LIST.get_next()
CTRL_C = None
while SCREEN is not None:
logging.debug("Install profile:\n%s", INSTALL_PROFILE)
logging.debug("Displaying screen: %s", type(SCREEN))
print("Invalid second arguement")
continue
elif (command == "platform"):
command = str(input("What element? >"))
if (command == "type"):
print(platform.machine())
elif (command == "system"):
print(platform.system())
elif (command == "os"):
print(platform.platform())
elif (command == "ver"):
print(platform.version())
elif (command == "dvcmdl"):
print(platform.uname())
elif (command == "processor"):
print(platform.processor())
elif (command == "arch"):
print(platform.architecture())
elif (command == "node"):
print(platform.node())
elif (command == "pybuild"):
print(platform.python_build())
elif (command == "pyver"):
print(platform.python_version())
elif (command == "compiler"):
print(platform.python_compiler())
elif (command == "imp"):
print(platform.python_implementation())
elif (command == "release"):
print(platform.release())
else:
def __init__(self, *args, mode=None):
QApplication.__init__(self, *args)
# Log some basic system info
try:
v = openshot.GetVersion()
log.info("openshot-qt version: %s" % info.VERSION)
log.info("libopenshot version: %s" % v.ToString())
log.info("platform: %s" % platform.platform())
log.info("processor: %s" % platform.processor())
log.info("machine: %s" % platform.machine())
log.info("python version: %s" % platform.python_version())
log.info("qt5 version: %s" % QT_VERSION_STR)
log.info("pyqt5 version: %s" % PYQT_VERSION_STR)
except:
pass
# Setup appication
self.setApplicationName('openshot')
self.setApplicationVersion(info.SETUP['version'])
# Init settings
self.settings = settings.SettingStore()
try:
self.settings.load()
except Exception as ex:
log.error("Couldn't load user settings. Exiting.\n{}".format(ex))
exit()
# Init translation system
language.init_language()
# Tests of project data loading/saving
self.project = project_data.ProjectDataStore()
# Init Update Manager
self.updates = updates.UpdateManager()
# It is important that the project is the first listener if the key gets update
self.updates.add_listener(self.project)
# Load ui theme if not set by OS
ui_util.load_theme()
# Start libopenshot logging thread
self.logger_libopenshot = logger_libopenshot.LoggerLibOpenShot()
self.logger_libopenshot.start()
# Track which dockable window received a context menu
self.context_menu_object = None
# Set unique install id (if blank)
if not self.settings.get("unique_install_id"):
self.settings.set("unique_install_id", str(uuid4()))
# Track 1st launch metric
import classes.metrics
classes.metrics.track_metric_screen("initial-launch-screen")
# Set Font for any theme
if self.settings.get("theme") != "No Theme":
# Load embedded font
try:
log.info(
"Setting font to %s" %
os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_id = QFontDatabase.addApplicationFont(
os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
font = QFont(font_family)
font.setPointSizeF(10.5)
QApplication.setFont(font)
except Exception as ex:
log.error("Error setting Ubuntu-R.ttf QFont: %s" % str(ex))
# Set Experimental Dark Theme
if self.settings.get("theme") == "Humanity: Dark":
# Only set if dark theme selected
log.info("Setting custom dark theme")
self.setStyle(QStyleFactory.create("Fusion"))
darkPalette = self.palette()
darkPalette.setColor(QPalette.Window, QColor(53, 53, 53))
darkPalette.setColor(QPalette.WindowText, Qt.white)
darkPalette.setColor(QPalette.Base, QColor(25, 25, 25))
darkPalette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ToolTipBase, Qt.white)
darkPalette.setColor(QPalette.ToolTipText, Qt.white)
darkPalette.setColor(QPalette.Text, Qt.white)
darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ButtonText, Qt.white)
darkPalette.setColor(QPalette.BrightText, Qt.red)
darkPalette.setColor(QPalette.Highlight, QColor(42, 130, 218))
darkPalette.setColor(QPalette.HighlightedText, Qt.black)
darkPalette.setColor(QPalette.Disabled, QPalette.Text,
QColor(104, 104, 104))
self.setPalette(darkPalette)
self.setStyleSheet(
"QToolTip { color: #ffffff; background-color: #2a82da; border: 0px solid white; }"
)
# Create main window
from windows.main_window import MainWindow
self.window = MainWindow(mode)
log.info('Process command-line arguments: %s' % args)
if len(args[0]) == 2:
path = args[0][1]
if ".osp" in path:
# Auto load project passed as argument
self.window.open_project(path)
else:
# Auto import media file
self.window.filesTreeView.add_file(path)
# Reset undo/redo history
self.updates.reset()
self.window.updateStatusChanged(False, False)
######################################################################
try:
conf['system'] = os.environ['UNAME']
except KeyError:
conf['system'] = platform.system()
conf['Linux?' ] = (conf['system'] == 'Linux')
conf['Solaris?'] = (conf['system'] == 'SunOS')
conf['Darwin?' ] = (conf['system'] == 'Darwin')
conf['FreeBSD?'] = (conf['system'] == 'FreeBSD')
conf['CYGWIN?' ] = (conf['system'] == 'CYGWIN')
conf['machine'] = platform.machine()
conf['processor'] = platform.processor()
conf['Intel?'] = (platform.machine() in ('i386', 'i486', 'i586', 'i686', 'x86_64',
'AMD64', 'i86pc'))
conf['IA64?'] = (platform.processor() == 'ia64')
conf['PPC?'] = (platform.processor() == 'powerpc')
conf['SPARC?'] = (platform.processor() == 'sparc')
######################################################################
### bit width
######################################################################
conf['bits'] = platform.architecture()[0]
if os.environ.get('SAGE64', 'no') == 'yes':
assert conf['bits'] == '64bit', 'SAGE64=yes on a 32-bit system!'
import platform print "Operating System: " + platform.system() print "OS Version: " + platform.release() print "OS Minor Version: " + platform.version() print "Network Name: " + platform.node() print "Processor Type: " + platform.machine() print "Processor Details: " + platform.processor() print "Python Version: " + platform.python_version()
def test_processor(self):
res = platform.processor()
