mirror of https://github.com/opencv/opencv.git
Open Source Computer Vision Library
https://opencv.org/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
200 lines
7.0 KiB
200 lines
7.0 KiB
#!/usr/bin/env python |
|
""" Utility package for run.py |
|
""" |
|
|
|
import sys |
|
import os |
|
import platform |
|
import re |
|
import tempfile |
|
import glob |
|
import logging |
|
import shutil |
|
from subprocess import check_call, check_output, CalledProcessError, STDOUT |
|
|
|
|
|
def initLogger(): |
|
logger = logging.getLogger("run.py") |
|
logger.setLevel(logging.DEBUG) |
|
ch = logging.StreamHandler(sys.stderr) |
|
ch.setFormatter(logging.Formatter("%(message)s")) |
|
logger.addHandler(ch) |
|
return logger |
|
|
|
|
|
log = initLogger() |
|
hostos = os.name # 'nt', 'posix' |
|
|
|
|
|
class Err(Exception): |
|
def __init__(self, msg, *args): |
|
self.msg = msg % args |
|
|
|
|
|
def execute(cmd, silent=False, cwd=".", env=None): |
|
try: |
|
log.debug("Run: %s", cmd) |
|
if env is not None: |
|
for k in env: |
|
log.debug(" Environ: %s=%s", k, env[k]) |
|
new_env = os.environ.copy() |
|
new_env.update(env) |
|
env = new_env |
|
|
|
if sys.platform == 'darwin': # https://github.com/opencv/opencv/issues/14351 |
|
if env is None: |
|
env = os.environ.copy() |
|
if 'DYLD_LIBRARY_PATH' in env: |
|
env['OPENCV_SAVED_DYLD_LIBRARY_PATH'] = env['DYLD_LIBRARY_PATH'] |
|
|
|
if silent: |
|
return check_output(cmd, stderr=STDOUT, cwd=cwd, env=env).decode("latin-1") |
|
else: |
|
return check_call(cmd, cwd=cwd, env=env) |
|
except CalledProcessError as e: |
|
if silent: |
|
log.debug("Process returned: %d", e.returncode) |
|
return e.output.decode("latin-1") |
|
else: |
|
log.error("Process returned: %d", e.returncode) |
|
return e.returncode |
|
|
|
|
|
def isColorEnabled(args): |
|
usercolor = [a for a in args if a.startswith("--gtest_color=")] |
|
return len(usercolor) == 0 and sys.stdout.isatty() and hostos != "nt" |
|
|
|
|
|
def getPlatformVersion(): |
|
mv = platform.mac_ver() |
|
if mv[0]: |
|
return "Darwin" + mv[0] |
|
else: |
|
wv = platform.win32_ver() |
|
if wv[0]: |
|
return "Windows" + wv[0] |
|
else: |
|
lv = platform.linux_distribution() |
|
if lv[0]: |
|
return lv[0] + lv[1] |
|
return None |
|
|
|
|
|
parse_patterns = ( |
|
{'name': "cmake_home", 'default': None, 'pattern': re.compile(r"^CMAKE_HOME_DIRECTORY:\w+=(.+)$")}, |
|
{'name': "opencv_home", 'default': None, 'pattern': re.compile(r"^OpenCV_SOURCE_DIR:\w+=(.+)$")}, |
|
{'name': "opencv_build", 'default': None, 'pattern': re.compile(r"^OpenCV_BINARY_DIR:\w+=(.+)$")}, |
|
{'name': "tests_dir", 'default': None, 'pattern': re.compile(r"^EXECUTABLE_OUTPUT_PATH:\w+=(.+)$")}, |
|
{'name': "build_type", 'default': "Release", 'pattern': re.compile(r"^CMAKE_BUILD_TYPE:\w+=(.*)$")}, |
|
{'name': "android_abi", 'default': None, 'pattern': re.compile(r"^ANDROID_ABI:\w+=(.*)$")}, |
|
{'name': "android_executable", 'default': None, 'pattern': re.compile(r"^ANDROID_EXECUTABLE:\w+=(.*android.*)$")}, |
|
{'name': "ant_executable", 'default': None, 'pattern': re.compile(r"^ANT_EXECUTABLE:\w+=(.*ant.*)$")}, |
|
{'name': "java_test_dir", 'default': None, 'pattern': re.compile(r"^OPENCV_JAVA_TEST_DIR:\w+=(.*)$")}, |
|
{'name': "is_x64", 'default': "OFF", 'pattern': re.compile(r"^CUDA_64_BIT_DEVICE_CODE:\w+=(ON)$")}, |
|
{'name': "cmake_generator", 'default': None, 'pattern': re.compile(r"^CMAKE_GENERATOR:\w+=(.+)$")}, |
|
{'name': "python3", 'default': None, 'pattern': re.compile(r"^BUILD_opencv_python3:\w+=(.*)$")}, |
|
) |
|
|
|
|
|
class CMakeCache: |
|
def __init__(self, cfg=None): |
|
self.setDefaultAttrs() |
|
self.main_modules = [] |
|
if cfg: |
|
self.build_type = cfg |
|
|
|
def setDummy(self, path): |
|
self.tests_dir = os.path.normpath(path) |
|
|
|
def read(self, path, fname): |
|
rx = re.compile(r'^OPENCV_MODULE_opencv_(\w+)_LOCATION:INTERNAL=(.*)$') |
|
module_paths = {} # name -> path |
|
with open(fname, "rt") as cachefile: |
|
for l in cachefile.readlines(): |
|
ll = l.strip() |
|
if not ll or ll.startswith("#"): |
|
continue |
|
for p in parse_patterns: |
|
match = p["pattern"].match(ll) |
|
if match: |
|
value = match.groups()[0] |
|
if value and not value.endswith("-NOTFOUND"): |
|
setattr(self, p["name"], value) |
|
# log.debug("cache value: %s = %s", p["name"], value) |
|
|
|
match = rx.search(ll) |
|
if match: |
|
module_paths[match.group(1)] = match.group(2) |
|
|
|
if not self.tests_dir: |
|
self.tests_dir = path |
|
else: |
|
rel = os.path.relpath(self.tests_dir, self.opencv_build) |
|
self.tests_dir = os.path.join(path, rel) |
|
self.tests_dir = os.path.normpath(self.tests_dir) |
|
|
|
# fix VS test binary path (add Debug or Release) |
|
if "Visual Studio" in self.cmake_generator: |
|
self.tests_dir = os.path.join(self.tests_dir, self.build_type) |
|
|
|
for module, path in module_paths.items(): |
|
rel = os.path.relpath(path, self.opencv_home) |
|
if ".." not in rel: |
|
self.main_modules.append(module) |
|
|
|
def setDefaultAttrs(self): |
|
for p in parse_patterns: |
|
setattr(self, p["name"], p["default"]) |
|
|
|
def gatherTests(self, mask, isGood=None): |
|
if self.tests_dir and os.path.isdir(self.tests_dir): |
|
d = os.path.abspath(self.tests_dir) |
|
files = glob.glob(os.path.join(d, mask)) |
|
if not self.getOS() == "android" and self.withJava(): |
|
files.append("java") |
|
if self.withPython3(): |
|
files.append("python3") |
|
return [f for f in files if isGood(f)] |
|
return [] |
|
|
|
def isMainModule(self, name): |
|
return name in self.main_modules + ['python3'] |
|
|
|
def withJava(self): |
|
return self.ant_executable and self.java_test_dir and os.path.exists(self.java_test_dir) |
|
|
|
def withPython3(self): |
|
return self.python3 == 'ON' |
|
|
|
def getOS(self): |
|
if self.android_executable: |
|
return "android" |
|
else: |
|
return hostos |
|
|
|
|
|
class TempEnvDir: |
|
def __init__(self, envname, prefix): |
|
self.envname = envname |
|
self.prefix = prefix |
|
self.saved_name = None |
|
self.new_name = None |
|
|
|
def init(self): |
|
self.saved_name = os.environ.get(self.envname) |
|
self.new_name = tempfile.mkdtemp(prefix=self.prefix, dir=self.saved_name or None) |
|
os.environ[self.envname] = self.new_name |
|
|
|
def clean(self): |
|
if self.saved_name: |
|
os.environ[self.envname] = self.saved_name |
|
else: |
|
del os.environ[self.envname] |
|
try: |
|
shutil.rmtree(self.new_name) |
|
except: |
|
pass |
|
|
|
|
|
if __name__ == "__main__": |
|
log.error("This is utility file, please execute run.py script")
|
|
|