# Copyright 2019 The TensorFlow Authors. All Rights Reserved.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

# ==============================================================================

"""Provides wrapper for TensorFlow modules."""

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import importlib

import sys

import types

from tensorflow.python.platform import tf_logging as logging

from tensorflow.python.util import tf_decorator

from tensorflow.python.util import tf_inspect

from tensorflow.python.util import tf_stack

from tensorflow.tools.compatibility import all_renames_v2

_PER_MODULE_WARNING_LIMIT = 1

def get_rename_v2(name):

if name not in all_renames_v2.symbol_renames:

return None

return all_renames_v2.symbol_renames[name]

def _call_location():

# We want to get stack frame 3 frames up from current frame,

# i.e. above __getattr__, _tfmw_add_deprecation_warning,

# and _call_location calls.

stack = tf_stack.extract_stack_file_and_line(max_length=4)

if not stack: # should never happen as we're in a function

return 'UNKNOWN'

frame = stack[0]

return '{}:{}'.format(frame.file, frame.line)

def contains_deprecation_decorator(decorators):

return any(

d.decorator_name == 'deprecated' for d in decorators)

def has_deprecation_decorator(symbol):

"""Checks if given object has a deprecation decorator.

We check if deprecation decorator is in decorators as well as

whether symbol is a class whose __init__ method has a deprecation

decorator.

Args:

symbol: Python object.

Returns:

True if symbol has deprecation decorator.

"""

decorators, symbol = tf_decorator.unwrap(symbol)

if contains_deprecation_decorator(decorators):

return True

if tf_inspect.isfunction(symbol):

return False

if not tf_inspect.isclass(symbol):

return False

if not hasattr(symbol, '__init__'):

return False

init_decorators, _ = tf_decorator.unwrap(symbol.__init__)

return contains_deprecation_decorator(init_decorators)

class TFModuleWrapper(types.ModuleType):

"""Wrapper for TF modules to support deprecation messages and lazyloading."""

def __init__( # pylint: disable=super-on-old-class

self,

wrapped,

module_name,

public_apis=None,

deprecation=True,

has_lite=False): # pylint: enable=super-on-old-class

super(TFModuleWrapper, self).__init__(wrapped.__name__)

self.__dict__.update(wrapped.__dict__)

# Prefix all local attributes with _tfmw_ so that we can

# handle them differently in attribute access methods.

self._tfmw_wrapped_module = wrapped

self._tfmw_module_name = module_name

self._tfmw_public_apis = public_apis

self._tfmw_print_deprecation_warnings = deprecation

self._tfmw_has_lite = has_lite

# Set __all__ so that import * work for lazy loaded modules

if self._tfmw_public_apis:

self._tfmw_wrapped_module.__all__ = list(self._tfmw_public_apis.keys())

self.__all__ = list(self._tfmw_public_apis.keys())

else:

if hasattr(self._tfmw_wrapped_module, '__all__'):

self.__all__ = self._tfmw_wrapped_module.__all__

else:

self._tfmw_wrapped_module.__all__ = [

attr for attr in dir(self._tfmw_wrapped_module)

if not attr.startswith('_')

]

self.__all__ = self._tfmw_wrapped_module.__all__

# names we already checked for deprecation

self._tfmw_deprecated_checked = set()

self._tfmw_warning_count = 0

def _tfmw_add_deprecation_warning(self, name, attr):

"""Print deprecation warning for attr with given name if necessary."""

if (self._tfmw_warning_count < _PER_MODULE_WARNING_LIMIT and

name not in self._tfmw_deprecated_checked):

self._tfmw_deprecated_checked.add(name)

if self._tfmw_module_name:

full_name = 'tf.%s.%s' % (self._tfmw_module_name, name)

else:

full_name = 'tf.%s' % name

rename = get_rename_v2(full_name)

if rename and not has_deprecation_decorator(attr):

call_location = _call_location()

# skip locations in Python source

if not call_location.startswith('<'):

logging.warning(

'From %s: The name %s is deprecated. Please use %s instead.\n',

_call_location(), full_name, rename)

self._tfmw_warning_count += 1

def _tfmw_import_module(self, name):

symbol_loc_info = self._tfmw_public_apis[name]

if symbol_loc_info[0]:

module = importlib.import_module(symbol_loc_info[0])

attr = getattr(module, symbol_loc_info[1])

else:

attr = importlib.import_module(symbol_loc_info[1])

setattr(self._tfmw_wrapped_module, name, attr)

self.__dict__[name] = attr

return attr

def __getattribute__(self, name): # pylint: disable=super-on-old-class

# Workaround to make sure we do not import from tensorflow/lite/__init__.py

if name == 'lite':

if self._tfmw_has_lite:

attr = self._tfmw_import_module(name)

setattr(self._tfmw_wrapped_module, 'lite', attr)

return attr

attr = super(TFModuleWrapper, self).__getattribute__(name)

if name.startswith('__') or name.startswith('_tfmw_'):

return attr

if self._tfmw_print_deprecation_warnings:

self._tfmw_add_deprecation_warning(name, attr)

return attr

def __getattr__(self, name):

try:

attr = getattr(self._tfmw_wrapped_module, name)

except AttributeError as e:

if not self._tfmw_public_apis:

raise

if name not in self._tfmw_public_apis:

raise

attr = self._tfmw_import_module(name)

if self._tfmw_print_deprecation_warnings:

self._tfmw_add_deprecation_warning(name, attr)

return attr

def __setattr__(self, arg, val): # pylint: disable=super-on-old-class

if not arg.startswith('_tfmw_'):

setattr(self._tfmw_wrapped_module, arg, val)

self.__dict__[arg] = val

if arg not in self.__all__ and arg != '__all__':

self.__all__.append(arg)

super(TFModuleWrapper, self).__setattr__(arg, val)

def __dir__(self):

if self._tfmw_public_apis:

return list(

set(self._tfmw_public_apis.keys()).union(

set([

attr for attr in dir(self._tfmw_wrapped_module)

if not attr.startswith('_')

])))

else:

return dir(self._tfmw_wrapped_module)

def __delattr__(self, name): # pylint: disable=super-on-old-class

if name.startswith('_tfmw_'):

super(TFModuleWrapper, self).__delattr__(name)

else:

delattr(self._tfmw_wrapped_module, name)

def __repr__(self):

return self._tfmw_wrapped_module.__repr__()

def __getstate__(self):

return self.__name__

def __setstate__(self, d):

# pylint: disable=protected-access

self.__init__(sys.modules[d]._tfmw_wrapped_module,

sys.modules[d]._tfmw_module_name)

# pylint: enable=protected-access