forked from nudt_dsp/netrans
326 lines
14 KiB
Python
326 lines
14 KiB
Python
import sys
|
|
import platform
|
|
import importlib
|
|
using_distro = False
|
|
try:
|
|
import distro
|
|
using_distro = True
|
|
except ImportError:
|
|
pass
|
|
from argparse import ArgumentParser
|
|
|
|
def main():
|
|
options = ArgumentParser(description='Netrans environment check tool.')
|
|
|
|
options.add_argument('--distribution',
|
|
action='store_true',
|
|
help='if it is a distribution environment')
|
|
args = options.parse_args()
|
|
|
|
check_status = check_env(args.distribution)
|
|
if check_status is True:
|
|
sys.exit(0)
|
|
else:
|
|
sys.exit(-1)
|
|
|
|
def version_compare(version1, version2):
|
|
sub_version1 = [int(x) for x in version1.split('.')]
|
|
sub_version2 = [int(x) for x in version2.split('.')]
|
|
|
|
max_len = max(len(sub_version1), len(sub_version2))
|
|
|
|
if len(sub_version1) < max_len:
|
|
sub_version1.extend([0] * (max_len-len(sub_version1)))
|
|
|
|
if len(sub_version2) < max_len:
|
|
sub_version2.extend([0] * (max_len-len(sub_version2)))
|
|
|
|
for i in range(max_len):
|
|
ret = sub_version1[i] - sub_version2[i]
|
|
if ret != 0:
|
|
return ret
|
|
return 0
|
|
|
|
def is_avx_support():
|
|
# Check Processor avx instruction set.
|
|
avx_support = True
|
|
with open('/proc/cpuinfo', 'r') as f:
|
|
processor = ''
|
|
for line in f.readlines():
|
|
line = line.strip()
|
|
if len(line) == 0:
|
|
continue
|
|
key, val = line.split(':')
|
|
key = key.strip()
|
|
val = val.strip()
|
|
if 'processor' == key:
|
|
processor = val
|
|
if 'flags' == key:
|
|
sets = val.split(' ')
|
|
if 'avx' not in sets:
|
|
avx_support = False
|
|
print('Env Error: Processor {} not support instruction set avx'.format(processor), flush=True)
|
|
return avx_support
|
|
|
|
def check_env(distribution_env = False):
|
|
env_check_status = True
|
|
|
|
# Check OS
|
|
OS = platform.system().lower()
|
|
python_ver = platform.python_version()
|
|
|
|
# Check machine type, architecture
|
|
platform_machine = platform.machine()
|
|
platform_architecture = platform.architecture()
|
|
if not platform_machine.endswith('64'):
|
|
env_check_status = False
|
|
print('Env Error: Require machine type 64bit, but {} installed'.format(platform_architecture), flush=True)
|
|
else:
|
|
print('Env Pass: Require machine type 64bit installed', flush=True)
|
|
if platform_architecture[0] != '64bit':
|
|
env_check_status = False
|
|
print('Env Error: Require OS type 64bit, but {} installed'.format(platform_architecture[0]), flush=True)
|
|
else:
|
|
print('Env Pass: Require OS type 64bit installed', flush=True)
|
|
|
|
if OS == 'linux':
|
|
if using_distro:
|
|
linux_os = distro.id().lower()
|
|
linux_os_ver = distro.version()
|
|
else:
|
|
distribution = platform.linux_distribution()
|
|
linux_os = distribution[0].lower()
|
|
linux_os_ver = distribution[1]
|
|
|
|
require_python_ver_major = '0'
|
|
require_python_ver_minor = '0'
|
|
require_pyinstaller_version = ''
|
|
|
|
if linux_os == 'ubuntu' and linux_os_ver == '16.04':
|
|
require_python_ver_major = 3
|
|
require_python_ver_minor = 5
|
|
require_pyinstaller_version = '3.4'
|
|
print(
|
|
"Env Info: Linux distribution is {} {}, please make sure python {}.{} installed." \
|
|
.format(linux_os, linux_os_ver, require_python_ver_major, require_python_ver_minor), flush=True)
|
|
elif linux_os == 'ubuntu' and linux_os_ver == '18.04':
|
|
require_python_ver_major = 3
|
|
require_python_ver_minor = 6
|
|
require_pyinstaller_version = '3.4'
|
|
print(
|
|
"Env Info: Linux distribution is {} {}, please make sure python {}.{} installed properly." \
|
|
.format(linux_os, linux_os_ver, require_python_ver_major, require_python_ver_minor), flush=True)
|
|
elif linux_os == 'ubuntu' and linux_os_ver == '20.04':
|
|
require_python_ver_major = 3
|
|
require_python_ver_minor = 8
|
|
require_pyinstaller_version = '4.5.1;5.13.0'
|
|
print(
|
|
"Env Warning: Linux distribution is {} {}, please make sure python {}.{} installed properly." \
|
|
.format(linux_os, linux_os_ver, require_python_ver_major, require_python_ver_minor), flush=True)
|
|
elif linux_os == 'ubuntu' and linux_os_ver == '22.04':
|
|
require_python_ver_major = 3
|
|
require_python_ver_minor = 10
|
|
require_pyinstaller_version = '5.7.0;5.13.0'
|
|
print(
|
|
"Env Warning: Linux distribution is {} {}, please make sure python {}.{} installed properly." \
|
|
.format(linux_os, linux_os_ver, require_python_ver_major, require_python_ver_minor), flush=True)
|
|
else:
|
|
env_check_status = False
|
|
print(
|
|
"Env Error: Linux distribution is {} {}, python is {}, not supported." \
|
|
.format(linux_os, linux_os_ver, python_ver), flush=True)
|
|
|
|
# Check Processor avx instruction set.
|
|
if is_avx_support():
|
|
print('Env Pass: All Processors support instruction set avx', flush=True)
|
|
else:
|
|
env_check_status = False
|
|
print('Env Error: Not All Processors support instruction set avx', flush=True)
|
|
|
|
elif OS == 'windows':
|
|
WIN_RELEASE = platform.release().lower()
|
|
if WIN_RELEASE in ['2012serverr2']:
|
|
require_python_ver_major = 3
|
|
require_python_ver_minor = 8
|
|
require_pyinstaller_version = '4.5.1'
|
|
print(
|
|
"Env Warning: OS is {} {}, please make sure python {}.{} installed properly." \
|
|
.format(OS, WIN_RELEASE, require_python_ver_major, require_python_ver_minor), flush=True)
|
|
else:
|
|
env_check_status = False
|
|
print(
|
|
"Env Error: OS isis {} {}, python is {}, not supported." \
|
|
.format(OS, WIN_RELEASE, python_ver), flush=True)
|
|
|
|
else:
|
|
print("Env Error: OS {}, python is {}, Not supported.".format(OS, python_ver),
|
|
flush=True)
|
|
env_check_status = False
|
|
|
|
# check python version
|
|
if version_compare(python_ver,"{}.{}.{}".format(require_python_ver_major, require_python_ver_minor, 0)) >= 0 \
|
|
and version_compare(python_ver, "{}.{}".format(require_python_ver_major, require_python_ver_minor + 1)) < 0:
|
|
print("Env Pass: Python {} installed, require {}.{}.x"
|
|
.format(python_ver, require_python_ver_major, require_python_ver_minor), flush=True)
|
|
else:
|
|
print("Env Error: Python {} installed, require {}.{}.x"
|
|
.format(python_ver, require_python_ver_major, require_python_ver_minor), flush=True)
|
|
env_check_status = False
|
|
|
|
# check python library version
|
|
require_libs = ['PyInstaller=={}'.format(require_pyinstaller_version), 'Cython>=0.29','setuptools>=41.2.0',
|
|
'scipy',
|
|
'tensorflow==2.3.0;2.6.0;2.8.0;2.10.0;2.12.0;2.15.0',
|
|
'google.protobuf<=3.20.3',
|
|
'networkx>=1.11', 'lmdb==0.93;1.0.0;1.1.0', 'onnx==1.8.0;1.10.2;1.11.0;1.12.0;1.14.0',
|
|
'flatbuffers', 'dill==0.2.8.2', 'ruamel.yaml==0.15.81;0.16.0',
|
|
'ply==3.11', 'torch>=1.5.1',
|
|
'cv2==4.6.0']
|
|
deprecated_env_ignore_libs = {
|
|
'3.5.': ['cv2'],
|
|
}
|
|
non_distribution_env_ignore_libs = ['PyInstaller', 'Cython', 'setuptools', 'cv2']
|
|
|
|
for lib in require_libs:
|
|
require_lib_name = ''
|
|
require_lib_compare_sign = ''
|
|
require_lib_ver = ''
|
|
if '==' in lib:
|
|
lib_name_list = lib.split('==')
|
|
if len(lib_name_list) == 1:
|
|
require_lib_compare_sign = '=='
|
|
else:
|
|
lib_versions = lib_name_list[1].split(';')
|
|
if len(lib_versions) == 1:
|
|
require_lib_compare_sign = '=='
|
|
else:
|
|
require_lib_compare_sign = 'in'
|
|
elif '>=' in lib:
|
|
require_lib_compare_sign = '>='
|
|
lib_name_list = lib.split('>=')
|
|
elif '<=' in lib:
|
|
require_lib_compare_sign = '<='
|
|
lib_name_list = lib.split('<=')
|
|
elif '>' in lib:
|
|
require_lib_compare_sign = '>'
|
|
lib_name_list = lib.split('>')
|
|
elif '<' in lib:
|
|
require_lib_compare_sign = '<'
|
|
lib_name_list = lib.split('<')
|
|
else:
|
|
require_lib_compare_sign = None
|
|
lib_name_list = [lib]
|
|
if len(lib_name_list) == 1:
|
|
require_lib_name = lib_name_list[0]
|
|
elif len(lib_name_list) == 2:
|
|
require_lib_name = lib_name_list[0]
|
|
lib_versions = lib_name_list[1].split(';')
|
|
if len(lib_versions) == 1:
|
|
require_lib_ver = str(lib_versions[0])
|
|
else:
|
|
require_lib_ver = lib_versions
|
|
else:
|
|
print("Env Error: Parse require libs failed, unexpected segment.", flush=True)
|
|
env_check_status = False
|
|
|
|
ignore = False
|
|
if require_lib_name != '':
|
|
for key in deprecated_env_ignore_libs.keys():
|
|
if python_ver.startswith(key) and require_lib_name in deprecated_env_ignore_libs[key]:
|
|
#ignore libs for deprecated env
|
|
ignore = True
|
|
break
|
|
if ignore:
|
|
continue
|
|
if not distribution_env and require_lib_name in non_distribution_env_ignore_libs:
|
|
continue #ignore libs for non-distribuition-env
|
|
|
|
python_lib = None
|
|
|
|
try:
|
|
python_lib = importlib.import_module(require_lib_name)
|
|
except:
|
|
print("Env Error: Require python lib {} import testing failed, not installed."
|
|
.format(require_lib_name), flush=True)
|
|
env_check_status = False
|
|
|
|
machine_python_lib_ver = ''
|
|
try:
|
|
if require_lib_compare_sign is not None:
|
|
if require_lib_name == 'image':
|
|
machine_python_lib_ver = python_lib.VERSION
|
|
machine_python_lib_ver = '.'.join(str(v) for v in machine_python_lib_ver)
|
|
elif require_lib_name == 'torch':
|
|
machine_python_lib_ver = python_lib.__version__.split('+')[0]
|
|
else:
|
|
machine_python_lib_ver = python_lib.__version__
|
|
except:
|
|
print("Env Error: Get Require python lib {} Version failed, please check build script."
|
|
.format(require_lib_name), flush=True)
|
|
env_check_status = False
|
|
if require_lib_compare_sign is None:
|
|
print("Env Pass: Required python lib {} version any, {} installed".
|
|
format(require_lib_name, machine_python_lib_ver))
|
|
else:
|
|
if require_lib_compare_sign == 'in':
|
|
compare_statement = "'{}' {} {}"\
|
|
.format(machine_python_lib_ver, require_lib_compare_sign, require_lib_ver)
|
|
compare_statement = eval(compare_statement)
|
|
elif require_lib_compare_sign == '>':
|
|
compare_statement = version_compare(machine_python_lib_ver, require_lib_ver) > 0
|
|
elif require_lib_compare_sign == '>=':
|
|
compare_statement = version_compare(machine_python_lib_ver, require_lib_ver) >= 0
|
|
elif require_lib_compare_sign == '<':
|
|
compare_statement = version_compare(machine_python_lib_ver, require_lib_ver) < 0
|
|
elif require_lib_compare_sign == '<=':
|
|
compare_statement = version_compare(machine_python_lib_ver, require_lib_ver) <= 0
|
|
else: # ==
|
|
compare_statement = version_compare(machine_python_lib_ver, require_lib_ver) == 0
|
|
if require_lib_ver != '' and compare_statement:
|
|
print("Env Pass: Require python lib {} version {} {}, {} installed."
|
|
.format(require_lib_name, require_lib_compare_sign, require_lib_ver, machine_python_lib_ver),
|
|
flush=True)
|
|
else:
|
|
print("Env Error: Require python lib {} version {} {}, but {} installed."
|
|
.format(require_lib_name, require_lib_compare_sign, require_lib_ver, machine_python_lib_ver),
|
|
flush=True)
|
|
env_check_status = False
|
|
else:
|
|
print("Env Error: Parse require libs failed, library name is null.", flush=True)
|
|
env_check_status = False
|
|
|
|
ONNX_ONNXOPTIMIZER_LIB = {
|
|
# '1.10.2': '0.2.6', # onnxoptimizer 0.2.6 don't have attribute __version__, mark this line
|
|
# '1.11.0': '0.2.6', # onnxoptimizer 0.2.6 don't have attribute __version__, mark this line
|
|
'1.12.0': '0.3.1',
|
|
'1.14.0': '0.3.13',
|
|
}
|
|
lib_onnx = importlib.import_module('onnx')
|
|
onnx_ver = lib_onnx.__version__
|
|
if onnx_ver in ONNX_ONNXOPTIMIZER_LIB:
|
|
onnxoptimizer_ver = ONNX_ONNXOPTIMIZER_LIB[onnx_ver]
|
|
try:
|
|
lib_onnxoptimizer = importlib.import_module('onnxoptimizer')
|
|
if version_compare(lib_onnxoptimizer.__version__, onnxoptimizer_ver) >= 0:
|
|
print("Env Pass: Installed onnxoptimizer {} is compatible with onnx {}."
|
|
.format(onnxoptimizer_ver, onnx_ver), flush=True)
|
|
else:
|
|
print("Env Error: Installed onnxoptimizer {} is NOT compatible with onnx {}."
|
|
.format(onnxoptimizer_ver, onnx_ver)
|
|
, flush=True)
|
|
env_check_status = False
|
|
except:
|
|
print("Env Error: Require python lib onnxoptimizer import testing failed, not installed."
|
|
, flush=True)
|
|
env_check_status = False
|
|
|
|
if env_check_status is False:
|
|
print("Env Error: Env check FAILED!!!", flush=True)
|
|
else:
|
|
print("Env Pass: Env check SUCCESS!!!", flush=True)
|
|
|
|
return env_check_status
|
|
|
|
if __name__ == '__main__':
|
|
main()
|