'tensorflow/lite/ios/BUILD', 'tensorflow/lite/objc/BUILD',

'tensorflow/lite/swift/BUILD',

'tensorflow/lite/tools/benchmark/experimental/ios/BUILD'

try:

try:

answer = raw_input(question)

except NameError:

answer = input(question) # pylint: disable=bad-builtin

except EOFError:

answer = ''

"""Force symlink, equivalent of 'ln -sf'.

try:

os.symlink(target, link_name)

except OSError as e:

if e.errno == errno.EEXIST:

os.remove(link_name)

os.symlink(target, link_name)

else:

if stderr is None:

stderr = sys.stdout

if allow_non_zero:

try:

output = subprocess.check_output(cmd, stderr=stderr)

except subprocess.CalledProcessError as e:

output = e.output

else:

output = subprocess.check_output(cmd, stderr=stderr)

"""Get the python site package paths."""

python_paths = []

if environ_cp.get('PYTHONPATH'):

python_paths = environ_cp.get('PYTHONPATH').split(':')

try:

stderr = open(os.devnull, 'wb')

library_paths = run_shell([

python_bin_path, '-c',

'import site; print("\\n".join(site.getsitepackages()))'

],

stderr=stderr).split('\n')

except subprocess.CalledProcessError:

library_paths = [

run_shell([

python_bin_path,

'-c',

'import sysconfig; print(sysconfig.get_path("purelib"))',

])

]

all_paths = set(python_paths + library_paths)

# Sort set so order is deterministic

all_paths = sorted(all_paths)

paths = []

for path in all_paths:

if os.path.isdir(path):

paths.append(path)

"""Setup python related env variables."""

# Get PYTHON_BIN_PATH, default is the current running python.

default_python_bin_path = sys.executable

ask_python_bin_path = ('Please specify the location of python. [Default is '

'{}]: ').format(default_python_bin_path)

while True:

python_bin_path = get_from_env_or_user_or_default(environ_cp,

'PYTHON_BIN_PATH',

ask_python_bin_path,

default_python_bin_path)

# Check if the path is valid

if os.path.isfile(python_bin_path) and os.access(python_bin_path, os.X_OK):

break

elif not os.path.exists(python_bin_path):

print('Invalid python path: {} cannot be found.'.format(python_bin_path))

else:

print('{} is not executable. Is it the python binary?'.format(

python_bin_path))

environ_cp['PYTHON_BIN_PATH'] = ''

# Convert python path to Windows style before checking lib and version

if is_windows() or is_cygwin():

python_bin_path = cygpath(python_bin_path)

# Get PYTHON_LIB_PATH

python_lib_path = environ_cp.get('PYTHON_LIB_PATH')

if not python_lib_path:

python_lib_paths = get_python_path(environ_cp, python_bin_path)

if environ_cp.get('USE_DEFAULT_PYTHON_LIB_PATH') == '1':

python_lib_path = python_lib_paths[0]

else:

print('Found possible Python library paths:\n %s' %

'\n '.join(python_lib_paths))

default_python_lib_path = python_lib_paths[0]

python_lib_path = get_input(

'Please input the desired Python library path to use. '

'Default is [{}]\n'.format(python_lib_paths[0]))

if not python_lib_path:

python_lib_path = default_python_lib_path

environ_cp['PYTHON_LIB_PATH'] = python_lib_path

python_major_version = get_python_major_version(python_bin_path)

if python_major_version == '2':

write_to_bazelrc('build --host_force_python=PY2')

# Convert python path to Windows style before writing into bazel.rc

if is_windows() or is_cygwin():

python_lib_path = cygpath(python_lib_path)

# Set-up env variables used by python_configure.bzl

write_action_env_to_bazelrc('PYTHON_BIN_PATH', python_bin_path)

write_action_env_to_bazelrc('PYTHON_LIB_PATH', python_lib_path)

write_to_bazelrc('build --python_path=\"{}"'.format(python_bin_path))

environ_cp['PYTHON_BIN_PATH'] = python_bin_path

# If chosen python_lib_path is from a path specified in the PYTHONPATH

# variable, need to tell bazel to include PYTHONPATH

if environ_cp.get('PYTHONPATH'):

python_paths = environ_cp.get('PYTHONPATH').split(':')

if python_lib_path in python_paths:

write_action_env_to_bazelrc('PYTHONPATH', environ_cp.get('PYTHONPATH'))

# Write tools/python_bin_path.sh

with open(

os.path.join(_TF_WORKSPACE_ROOT, 'tools', 'python_bin_path.sh'),

'w') as f:

"""Delete any leftover BUILD files from the Makefile build.

makefile_download_dir = os.path.join(_TF_WORKSPACE_ROOT, 'tensorflow',

'contrib', 'makefile', 'downloads')

if os.path.isdir(makefile_download_dir):

for root, _, filenames in os.walk(makefile_download_dir):

for f in filenames:

if f.endswith('BUILD'):

var_name,

query_item,

enabled_by_default,

question=None,

yes_reply=None,

no_reply=None):

"""Get boolean input from user.

if not question:

question = 'Do you wish to build TensorFlow with {} support?'.format(

query_item)

if not yes_reply:

yes_reply = '{} support will be enabled for TensorFlow.'.format(query_item)

if not no_reply:

no_reply = 'No {}'.format(yes_reply)

yes_reply += '\n'

no_reply += '\n'

if enabled_by_default:

question += ' [Y/n]: '

else:

question += ' [y/N]: '

var = environ_cp.get(var_name)

if var is not None:

var_content = var.strip().lower()

true_strings = ('1', 't', 'true', 'y', 'yes')

false_strings = ('0', 'f', 'false', 'n', 'no')

if var_content in true_strings:

var = True

elif var_content in false_strings:

var = False

else:

raise UserInputError(

'Environment variable %s must be set as a boolean indicator.\n'

'The following are accepted as TRUE : %s.\n'

'The following are accepted as FALSE: %s.\n'

'Current value is %s.' %

(var_name, ', '.join(true_strings), ', '.join(false_strings), var))

while var is None:

user_input_origin = get_input(question)

user_input = user_input_origin.strip().lower()

if user_input == 'y':

print(yes_reply)

var = True

elif user_input == 'n':

print(no_reply)

var = False

elif not user_input:

if enabled_by_default:

print(yes_reply)

var = True

else:

print(no_reply)

var = False

else:

print('Invalid selection: {}'.format(user_input_origin))

var_name,

query_item,

enabled_by_default,

question=None,

yes_reply=None,

no_reply=None,

bazel_config_name=None):

"""Set boolean action_env variable.

var = int(

get_var(environ_cp, var_name, query_item, enabled_by_default, question,

yes_reply, no_reply))

if not bazel_config_name:

write_action_env_to_bazelrc(var_name, var)

elif var:

write_to_bazelrc('build --config=%s' % bazel_config_name)

"""Convert a version number to a integer that can be used to compare.

version = version.split('-')[0]

version_segments = version.split('.')

# Treat "0.24" as "0.24.0"

if len(version_segments) == 2:

version_segments.append('0')

for seg in version_segments:

if not seg.isdigit():

return None

version_str = ''.join(['%03d' % int(seg) for seg in version_segments])

"""Retrieve installed bazel version (or bazelisk).

bazel_executable = shutil.which('bazel')

if bazel_executable is None:

bazel_executable = shutil.which('bazelisk')

if bazel_executable is None:

print('Cannot find bazel. Please install bazel/bazelisk.')

sys.exit(1)

stderr = open(os.devnull, 'wb')

curr_version = run_shell([bazel_executable, '--version'],

allow_non_zero=True,

stderr=stderr)

if curr_version.startswith('bazel '):

curr_version = curr_version.split('bazel ')[1]

curr_version_int = convert_version_to_int(curr_version)

# Check if current bazel version can be detected properly.

if not curr_version_int:

print('WARNING: current bazel installation is not a release version.')

return curr_version

print('You have bazel %s installed.' % curr_version)

"""Set up architecture-dependent optimization flags.

if is_ppc64le():

# gcc on ppc64le does not support -march, use mcpu instead

default_cc_opt_flags = '-mcpu=native'

elif is_windows():

default_cc_opt_flags = '/arch:AVX'

else:

# On all other platforms, no longer use `-march=native` as this can result

# in instructions that are too modern being generated. Users that want

# maximum performance should compile TF in their environment and can pass

# `-march=native` there.

# See https://github.com/tensorflow/tensorflow/issues/45744 and duplicates

default_cc_opt_flags = '-Wno-sign-compare'

question = ('Please specify optimization flags to use during compilation when'

' bazel option "--config=opt" is specified [Default is %s]: '

) % default_cc_opt_flags

cc_opt_flags = get_from_env_or_user_or_default(environ_cp, 'CC_OPT_FLAGS',

question, default_cc_opt_flags)

for opt in cc_opt_flags.split():

write_to_bazelrc('build:opt --copt=%s' % opt)

"""set TF_CUDA_CLANG action_env.

question = 'Do you want to use clang as CUDA compiler?'

yes_reply = 'Clang will be used as CUDA compiler.'

no_reply = 'nvcc will be used as CUDA compiler.'

set_action_env_var(

environ_cp,

'TF_CUDA_CLANG',

None,

True,

question=question,

yes_reply=yes_reply,

no_reply=no_reply,

bazel_config_name='cuda_clang',

"""Set TF_DOWNLOAD_CLANG action_env."""

question = 'Do you wish to download a fresh release of clang? (Experimental)'

yes_reply = 'Clang will be downloaded and used to compile tensorflow.'

no_reply = 'Clang will not be downloaded.'

set_action_env_var(

environ_cp,

'TF_DOWNLOAD_CLANG',

None,

False,

question=question,

yes_reply=yes_reply,

no_reply=no_reply,

var_default):

"""Get var_name either from env, or user or default.

var = environ_cp.get(var_name)

# an intentionally empty value in the

# environment is not the same as no value

if var is None:

var = get_input(ask_for_var)

print('\n')

if not var:

var = var_default

var_name,

var_default,

ask_for_var,

check_success,

error_msg,

suppress_default_error=False,

resolve_symlinks=False,

n_ask_attempts=_DEFAULT_PROMPT_ASK_ATTEMPTS):

"""Loop over user prompts for an ENV param until receiving a valid response.

default = environ_cp.get(var_name) or var_default

full_query = '%s [Default is %s]: ' % (

ask_for_var,

default,

)

for _ in range(n_ask_attempts):

val = get_from_env_or_user_or_default(environ_cp, var_name, full_query,

default)

if check_success(val):

break

if not suppress_default_error:

print(error_msg % val)

environ_cp[var_name] = ''

else:

raise UserInputError('Invalid %s setting was provided %d times in a row. '

'Assuming to be a scripting mistake.' %

(var_name, n_ask_attempts))

if resolve_symlinks:

val = os.path.realpath(val)

environ_cp[var_name] = val

"""Set CLANG_CUDA_COMPILER_PATH."""

# Upon clang 19 drop the check for 16

default_clang_path = '/usr/lib/llvm-18/bin/clang'

if not os.path.exists(default_clang_path):

default_clang_path = '/usr/lib/llvm-17/bin/clang'

if not os.path.exists(default_clang_path):

default_clang_path = '/usr/lib/llvm-16/bin/clang'

if not os.path.exists(default_clang_path):

default_clang_path = shutil.which('clang') or ''

clang_cuda_compiler_path = prompt_loop_or_load_from_env(

environ_cp,

var_name='CLANG_CUDA_COMPILER_PATH',

var_default=default_clang_path,

ask_for_var='Please specify clang path that to be used as host compiler.',

check_success=os.path.exists,

resolve_symlinks=True,

error_msg='Invalid clang path. %s cannot be found.',

)

# Set CLANG_CUDA_COMPILER_PATH

environ_cp['CLANG_CUDA_COMPILER_PATH'] = clang_cuda_compiler_path

write_action_env_to_bazelrc('CLANG_CUDA_COMPILER_PATH',

clang_cuda_compiler_path)

"""Set ANDROID_NDK_HOME and write Android NDK WORKSPACE rule."""

if is_windows() or is_cygwin():

default_ndk_path = cygpath('%s/Android/Sdk/ndk-bundle' %

environ_cp['APPDATA'])

elif is_macos():

default_ndk_path = '%s/library/Android/Sdk/ndk-bundle' % environ_cp['HOME']

else:

default_ndk_path = '%s/Android/Sdk/ndk-bundle' % environ_cp['HOME']

def valid_ndk_path(path):

return (os.path.exists(path) and

os.path.exists(os.path.join(path, 'source.properties')))

android_ndk_home_path = prompt_loop_or_load_from_env(

environ_cp,

var_name='ANDROID_NDK_HOME',

var_default=default_ndk_path,

ask_for_var='Please specify the home path of the Android NDK to use.',

check_success=valid_ndk_path,

error_msg=('The path %s or its child file "source.properties" '

'does not exist.'))

write_action_env_to_bazelrc('ANDROID_NDK_HOME', android_ndk_home_path)

write_action_env_to_bazelrc(

'ANDROID_NDK_API_LEVEL',

"""Set Android variables and write Android SDK WORKSPACE rule."""

if is_windows() or is_cygwin():

default_sdk_path = cygpath('%s/Android/Sdk' % environ_cp['APPDATA'])

elif is_macos():

default_sdk_path = '%s/library/Android/Sdk' % environ_cp['HOME']

else:

default_sdk_path = '%s/Android/Sdk' % environ_cp['HOME']

def valid_sdk_path(path):

return (os.path.exists(path) and

os.path.exists(os.path.join(path, 'platforms')) and

os.path.exists(os.path.join(path, 'build-tools')))

android_sdk_home_path = prompt_loop_or_load_from_env(

environ_cp,

var_name='ANDROID_SDK_HOME',

var_default=default_sdk_path,

ask_for_var='Please specify the home path of the Android SDK to use.',

check_success=valid_sdk_path,

error_msg=('Either %s does not exist, or it does not contain the '

'subdirectories "platforms" and "build-tools".'))

platforms = os.path.join(android_sdk_home_path, 'platforms')

api_levels = sorted(os.listdir(platforms))

api_levels = [x.replace('android-', '') for x in api_levels]

def valid_api_level(api_level):

return os.path.exists(

os.path.join(android_sdk_home_path, 'platforms',

'android-' + api_level))

android_api_level = prompt_loop_or_load_from_env(

environ_cp,

var_name='ANDROID_API_LEVEL',

var_default=api_levels[-1],

ask_for_var=('Please specify the Android SDK API level to use. '

'[Available levels: %s]') % api_levels,

check_success=valid_api_level,

error_msg='Android-%s is not present in the SDK path.')

build_tools = os.path.join(android_sdk_home_path, 'build-tools')

versions = sorted(os.listdir(build_tools))

def valid_build_tools(version):

return os.path.exists(

os.path.join(android_sdk_home_path, 'build-tools', version))

android_build_tools_version = prompt_loop_or_load_from_env(

environ_cp,

var_name='ANDROID_BUILD_TOOLS_VERSION',

var_default=versions[-1],

ask_for_var=('Please specify an Android build tools version to use. '

'[Available versions: %s]') % versions,

check_success=valid_build_tools,

error_msg=('The selected SDK does not have build-tools version %s '

'available.'))

write_action_env_to_bazelrc('ANDROID_BUILD_TOOLS_VERSION',

android_build_tools_version)

write_action_env_to_bazelrc('ANDROID_SDK_API_LEVEL', android_api_level)

"""Gets the appropriate NDK API level to use for the provided Android NDK path.

# First check to see if we're using a blessed version of the NDK.

properties_path = '%s/source.properties' % android_ndk_home_path

if is_windows() or is_cygwin():

properties_path = cygpath(properties_path)

with open(properties_path, 'r') as f:

filedata = f.read()

revision = re.search(r'Pkg.Revision = (\d+)', filedata)

if revision:

ndk_version = revision.group(1)

else:

raise Exception('Unable to parse NDK revision.')

if int(ndk_version) not in _SUPPORTED_ANDROID_NDK_VERSIONS:

print('WARNING: The NDK version in %s is %s, which is not '

'supported by Bazel (officially supported versions: %s). Please use '

'another version. Compiling Android targets may result in confusing '

'errors.\n' %

(android_ndk_home_path, ndk_version, _SUPPORTED_ANDROID_NDK_VERSIONS))

write_action_env_to_bazelrc('ANDROID_NDK_VERSION', ndk_version)

# Now grab the NDK API level to use. Note that this is different from the

# SDK API level, as the NDK API level is effectively the *min* target SDK

# version.

meta = open(os.path.join(android_ndk_home_path, 'meta/platforms.json'))

platforms = json.load(meta)

meta.close()

aliases = platforms['aliases']

api_levels = sorted(list(set([aliases[i] for i in aliases])))

android_ndk_api_level = prompt_loop_or_load_from_env(

environ_cp,

var_name='ANDROID_NDK_API_LEVEL',

var_default='21', # 21 is required for ARM64 support.

ask_for_var=(

'Please specify the (min) Android NDK API level to use. '

'[Available levels: %s]'

)

% api_levels,

check_success=(lambda *_: True),

error_msg='Android-%s is not present in the NDK path.',

)

"""Set GCC_HOST_COMPILER_PATH."""

default_gcc_host_compiler_path = shutil.which('gcc') or ''

gcc_host_compiler_path = prompt_loop_or_load_from_env(

environ_cp,

var_name='GCC_HOST_COMPILER_PATH',

var_default=default_gcc_host_compiler_path,

ask_for_var='Please specify which gcc should be used by nvcc as the host '

'compiler.',

check_success=os.path.exists,

resolve_symlinks=True,

error_msg='Invalid gcc path. %s cannot be found.',

)

question = 'Do you want to use Clang to build TensorFlow?'

yes_reply = 'Clang will be used to compile TensorFlow.'

no_reply = 'GCC will be used to compile TensorFlow.'

var = int(

get_var(

environ_cp, 'TF_NEED_CLANG', None, True, question, yes_reply, no_reply

)

)

question = 'Do you want to use Clang to build TensorFlow?'

yes_reply = 'Add "--config=win_clang" to compile TensorFlow with CLANG.'

no_reply = 'MSVC will be used to compile TensorFlow.'

var = int(

get_var(

environ_cp, 'TF_NEED_CLANG', None, True, question, yes_reply, no_reply

)

)

"""Set CLANG_COMPILER_PATH and environment variables.

# Default path if clang-18 is installed by using apt-get install

# remove 16 logic upon release of 19

default_clang_path = '/usr/lib/llvm-18/bin/clang'

if not os.path.exists(default_clang_path):

default_clang_path = '/usr/lib/llvm-17/bin/clang'

if not os.path.exists(default_clang_path):

default_clang_path = '/usr/lib/llvm-16/bin/clang'

if not os.path.exists(default_clang_path):

default_clang_path = shutil.which('clang') or ''

clang_compiler_path = prompt_loop_or_load_from_env(

environ_cp,

var_name='CLANG_COMPILER_PATH',

var_default=default_clang_path,

ask_for_var='Please specify the path to clang executable.',

check_success=os.path.exists,

resolve_symlinks=True,

error_msg=(

'Invalid clang path. %s cannot be found. Note that TensorFlow now'

' requires clang to compile. You may override this behavior by'

' setting TF_NEED_CLANG=0'

),

)

write_action_env_to_bazelrc('CLANG_COMPILER_PATH', clang_compiler_path)

write_to_bazelrc('build --repo_env=CC=%s' % clang_compiler_path)

write_to_bazelrc('build --repo_env=BAZEL_COMPILER=%s' % clang_compiler_path)

"""Set CLANG_COMPILER_PATH and environment variables.

# Default path if clang-16 is installed by using apt-get install

default_clang_path = 'C:/Program Files/LLVM/bin/clang.exe'

if not os.path.exists(default_clang_path):

default_clang_path = shutil.which('clang') or ''

clang_compiler_path = prompt_loop_or_load_from_env(

environ_cp,

var_name='CLANG_COMPILER_PATH',

var_default=default_clang_path,

ask_for_var='Please specify the path to clang executable.',

check_success=os.path.exists,

resolve_symlinks=True,

error_msg=(

'Invalid clang path. %s cannot be found. Note that Clang is now'

'preferred compiler. You may use MSVC by removing --config=win_clang'

),

)

write_action_env_to_bazelrc('CLANG_COMPILER_PATH', clang_compiler_path)

write_to_bazelrc(f'build --repo_env=CC="{clang_compiler_path}"')

write_to_bazelrc(f'build --repo_env=BAZEL_COMPILER="{clang_compiler_path}"')

"""Retrieve installed clang version.

stderr = open(os.devnull, 'wb')

curr_version = run_shell([clang_executable, '--version'],

allow_non_zero=True,

stderr=stderr)

curr_version_split = curr_version.lower().split('clang version ')

if len(curr_version_split) > 1:

curr_version = curr_version_split[1].split()[0].split('git')

if len(curr_version) > 1:

print('WARNING: current clang installation is not a release version.\n')

curr_version = curr_version[0]

curr_version_int = convert_version_to_int(curr_version)

# Check if current clang version can be detected properly.

if not curr_version_int:

print('WARNING: current clang installation version unknown.\n')

return None

print('You have Clang %s installed.\n' % curr_version)

"""Set HERMETIC_CUDA_VERSION."""

ask_cuda_version = (

'Please specify the hermetic CUDA version you want to use '

'or leave empty to use the default version. '

)

hermetic_cuda_version = get_from_env_or_user_or_default(

environ_cp, 'HERMETIC_CUDA_VERSION', ask_cuda_version, None

)

if hermetic_cuda_version:

environ_cp['HERMETIC_CUDA_VERSION'] = hermetic_cuda_version

write_repo_env_to_bazelrc(

'cuda', 'HERMETIC_CUDA_VERSION', hermetic_cuda_version

"""Set HERMETIC_CUDNN_VERSION."""

ask_cudnn_version = (

'Please specify the hermetic cuDNN version you want to use '

'or leave empty to use the default version. '

)

hermetic_cudnn_version = get_from_env_or_user_or_default(

environ_cp, 'HERMETIC_CUDNN_VERSION', ask_cudnn_version, None

)

if hermetic_cudnn_version:

environ_cp['HERMETIC_CUDNN_VERSION'] = hermetic_cudnn_version

write_repo_env_to_bazelrc(

'cuda', 'HERMETIC_CUDNN_VERSION', hermetic_cudnn_version

"""Set HERMETIC_CUDA_COMPUTE_CAPABILITIES."""

while True:

default_cuda_compute_capabilities = _DEFAULT_CUDA_COMPUTE_CAPABILITIES

ask_cuda_compute_capabilities = (

'Please specify a list of comma-separated CUDA compute capabilities '

'you want to build with.\nYou can find the compute capability of your '

'device at: https://developer.nvidia.com/cuda-gpus. Each capability '

'can be specified as "x.y" or "compute_xy" to include both virtual and'

' binary GPU code, or as "sm_xy" to only include the binary '

'code.\nPlease note that each additional compute capability '

'significantly increases your build time and binary size, and that '

'TensorFlow only supports compute capabilities >= 3.5 [Default is: '

'%s]: ' % default_cuda_compute_capabilities)

hermetic_cuda_compute_capabilities = get_from_env_or_user_or_default(

environ_cp,

'HERMETIC_CUDA_COMPUTE_CAPABILITIES',

ask_cuda_compute_capabilities,

default_cuda_compute_capabilities,

)

# Check whether all capabilities from the input is valid

all_valid = True

# Remove all whitespace characters before splitting the string

# that users may insert by accident, as this will result in error