text: # This file was automatically generated by SWIG (http://www.swig.org).
  # Version 3.0.10
  #
  # Do not make changes to this file unless you know what you are doing--modify
  # the SWIG interface file instead.
  
  
  
  
  
  from sys import version_info as _swig_python_version_info
  if _swig_python_version_info >= (2, 7, 0):
      def swig_import_helper():
          import importlib
          pkg = __name__.rpartition('.')[0]
          mname = '.'.join((pkg, '_pywrap_tensorflow_internal')).lstrip('.')
          try:
              return importlib.import_module(mname)
          except ImportError:
              return importlib.import_module('_pywrap_tensorflow_internal')
      _pywrap_tensorflow_internal = swig_import_helper()
      del swig_import_helper
  elif _swig_python_version_info >= (2, 6, 0):
      def swig_import_helper():
          from os.path import dirname
          import imp
          fp = None
          try:
              fp, pathname, description = imp.find_module('_pywrap_tensorflow_internal', [dirname(__file__)])
          except ImportError:
              import _pywrap_tensorflow_internal
              return _pywrap_tensorflow_internal
          if fp is not None:
              try:
                  _mod = imp.load_module('_pywrap_tensorflow_internal', fp, pathname, description)
              finally:
                  fp.close()
              return _mod
      _pywrap_tensorflow_internal = swig_import_helper()
      del swig_import_helper
  else:
      import _pywrap_tensorflow_internal
  del _swig_python_version_info
  try:
      _swig_property = property
  except NameError:
      pass  # Python < 2.2 doesn't have 'property'.
  
  try:
      import builtins as __builtin__
  except ImportError:
      import __builtin__
  
  def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
      if (name == "thisown"):
          return self.this.own(value)
      if (name == "this"):
          if type(value).__name__ == 'SwigPyObject':
              self.__dict__[name] = value
              return
      method = class_type.__swig_setmethods__.get(name, None)
      if method:
          return method(self, value)
      if (not static):
          if _newclass:
              object.__setattr__(self, name, value)
          else:
              self.__dict__[name] = value
      else:
          raise AttributeError("You cannot add attributes to %s" % self)
  
  
  def _swig_setattr(self, class_type, name, value):
      return _swig_setattr_nondynamic(self, class_type, name, value, 0)
  
  
  def _swig_getattr(self, class_type, name):
      if (name == "thisown"):
          return self.this.own()
      method = class_type.__swig_getmethods__.get(name, None)
      if method:
          return method(self)
      raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))
  
  
  def _swig_repr(self):
      try:
          strthis = "proxy of " + self.this.__repr__()
      except __builtin__.Exception:
          strthis = ""
      return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
  
  try:
      _object = object
      _newclass = 1
  except __builtin__.Exception:
      class _object:
          pass
      _newclass = 0
  
  
  def TFE_NewContext(opts, status):
      return _pywrap_tensorflow_internal.TFE_NewContext(opts, status)
  TFE_NewContext = _pywrap_tensorflow_internal.TFE_NewContext
  
  def TFE_DeleteContext(ctx, status):
      return _pywrap_tensorflow_internal.TFE_DeleteContext(ctx, status)
  TFE_DeleteContext = _pywrap_tensorflow_internal.TFE_DeleteContext
  
  def TFE_ContextListDevices(ctx, status):
      return _pywrap_tensorflow_internal.TFE_ContextListDevices(ctx, status)
  TFE_ContextListDevices = _pywrap_tensorflow_internal.TFE_ContextListDevices
  
  def TFE_NewOp(ctx, op_or_function_name, status):
      return _pywrap_tensorflow_internal.TFE_NewOp(ctx, op_or_function_name, status)
  TFE_NewOp = _pywrap_tensorflow_internal.TFE_NewOp
  
  def TFE_OpGetAttrType(op, attr_name, status):
      return _pywrap_tensorflow_internal.TFE_OpGetAttrType(op, attr_name, status)
  TFE_OpGetAttrType = _pywrap_tensorflow_internal.TFE_OpGetAttrType
  
  def TFE_ContextAddFunctionDef(ctx, serialized_function_def, size, status):
      return _pywrap_tensorflow_internal.TFE_ContextAddFunctionDef(ctx, serialized_function_def, size, status)
  TFE_ContextAddFunctionDef = _pywrap_tensorflow_internal.TFE_ContextAddFunctionDef
  
  def TFE_Py_Execute(ctx, device_name, op_name, inputs, attrs, outputs):
      return _pywrap_tensorflow_internal.TFE_Py_Execute(ctx, device_name, op_name, inputs, attrs, outputs)
  TFE_Py_Execute = _pywrap_tensorflow_internal.TFE_Py_Execute
  
  def TFE_Py_RegisterExceptionClass(e):
      return _pywrap_tensorflow_internal.TFE_Py_RegisterExceptionClass(e)
  TFE_Py_RegisterExceptionClass = _pywrap_tensorflow_internal.TFE_Py_RegisterExceptionClass
  
  def TFE_Py_UID():
      return _pywrap_tensorflow_internal.TFE_Py_UID()
  TFE_Py_UID = _pywrap_tensorflow_internal.TFE_Py_UID
  
  def TFE_Py_InitEagerTensor(base_class):
      return _pywrap_tensorflow_internal.TFE_Py_InitEagerTensor(base_class)
  TFE_Py_InitEagerTensor = _pywrap_tensorflow_internal.TFE_Py_InitEagerTensor
  
  def IsGoogleCudaEnabled():
      return _pywrap_tensorflow_internal.IsGoogleCudaEnabled()
  IsGoogleCudaEnabled = _pywrap_tensorflow_internal.IsGoogleCudaEnabled
  
  def CudaSupportsHalfMatMulAndConv():
      return _pywrap_tensorflow_internal.CudaSupportsHalfMatMulAndConv()
  CudaSupportsHalfMatMulAndConv = _pywrap_tensorflow_internal.CudaSupportsHalfMatMulAndConv
  
  def CheckpointReader_GetTensor(reader, name, out_status):
      return _pywrap_tensorflow_internal.CheckpointReader_GetTensor(reader, name, out_status)
  CheckpointReader_GetTensor = _pywrap_tensorflow_internal.CheckpointReader_GetTensor
  
  def NewCheckpointReader(filepattern):
    from tensorflow.python.framework import errors
    with errors.raise_exception_on_not_ok_status() as status:
      from tensorflow.python.util import compat
      return CheckpointReader(compat.as_bytes(filepattern), status)
  
  class CheckpointReader(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, CheckpointReader, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, CheckpointReader, name)
      __repr__ = _swig_repr
  
      def __init__(self, filepattern, out_status):
          this = _pywrap_tensorflow_internal.new_CheckpointReader(filepattern, out_status)
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
  
      def _HasTensor(self, name):
          return _pywrap_tensorflow_internal.CheckpointReader__HasTensor(self, name)
  
      def debug_string(self):
          return _pywrap_tensorflow_internal.CheckpointReader_debug_string(self)
  
      def get_variable_to_shape_map(self):
          return _pywrap_tensorflow_internal.CheckpointReader_get_variable_to_shape_map(self)
  
      def _GetVariableToDataTypeMap(self):
          return _pywrap_tensorflow_internal.CheckpointReader__GetVariableToDataTypeMap(self)
  
      def get_variable_to_dtype_map(self):
        from tensorflow.python.framework import dtypes
        return {name: dtypes.DType(type_enum)
                for name, type_enum in self._GetVariableToDataTypeMap().items()}
  
      def has_tensor(self, tensor_str):
        from tensorflow.python.util import compat
        return self._HasTensor(compat.as_bytes(tensor_str))
  
      def get_tensor(self, tensor_str):
        from tensorflow.python.framework import errors
        with errors.raise_exception_on_not_ok_status() as status:
          from tensorflow.python.util import compat
          return CheckpointReader_GetTensor(self, compat.as_bytes(tensor_str),
                                            status)
  
      __swig_destroy__ = _pywrap_tensorflow_internal.delete_CheckpointReader
      __del__ = lambda self: None
  CheckpointReader_swigregister = _pywrap_tensorflow_internal.CheckpointReader_swigregister
  CheckpointReader_swigregister(CheckpointReader)
  
  
  def NewStatSummarizer(unused):
      return _pywrap_tensorflow_internal.NewStatSummarizer(unused)
  NewStatSummarizer = _pywrap_tensorflow_internal.NewStatSummarizer
  
  def DeleteStatSummarizer(ss):
      return _pywrap_tensorflow_internal.DeleteStatSummarizer(ss)
  DeleteStatSummarizer = _pywrap_tensorflow_internal.DeleteStatSummarizer
  class StatSummarizer(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, StatSummarizer, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, StatSummarizer, name)
      __repr__ = _swig_repr
      __swig_destroy__ = _pywrap_tensorflow_internal.delete_StatSummarizer
      __del__ = lambda self: None
  
      def ProcessStepStats(self, step_stats):
          return _pywrap_tensorflow_internal.StatSummarizer_ProcessStepStats(self, step_stats)
  
      def GetOutputString(self):
          return _pywrap_tensorflow_internal.StatSummarizer_GetOutputString(self)
  
      def PrintStepStats(self):
          return _pywrap_tensorflow_internal.StatSummarizer_PrintStepStats(self)
  
      def ProcessStepStatsStr(self, step_stats_str):
          return _pywrap_tensorflow_internal.StatSummarizer_ProcessStepStatsStr(self, step_stats_str)
  
      def __init__(self, *args):
          this = _pywrap_tensorflow_internal.new_StatSummarizer(*args)
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
  StatSummarizer_swigregister = _pywrap_tensorflow_internal.StatSummarizer_swigregister
  StatSummarizer_swigregister(StatSummarizer)
  
  
  def NewProfiler(graph, op_log):
      return _pywrap_tensorflow_internal.NewProfiler(graph, op_log)
  NewProfiler = _pywrap_tensorflow_internal.NewProfiler
  
  def DeleteProfiler():
      return _pywrap_tensorflow_internal.DeleteProfiler()
  DeleteProfiler = _pywrap_tensorflow_internal.DeleteProfiler
  
  def AddStep(step, graph, run_meta, op_log):
      return _pywrap_tensorflow_internal.AddStep(step, graph, run_meta, op_log)
  AddStep = _pywrap_tensorflow_internal.AddStep
  
  def WriteProfile(filename):
      return _pywrap_tensorflow_internal.WriteProfile(filename)
  WriteProfile = _pywrap_tensorflow_internal.WriteProfile
  
  def ProfilerFromFile(filename):
      return _pywrap_tensorflow_internal.ProfilerFromFile(filename)
  ProfilerFromFile = _pywrap_tensorflow_internal.ProfilerFromFile
  
  def Profile(command, options):
      return _pywrap_tensorflow_internal.Profile(command, options)
  Profile = _pywrap_tensorflow_internal.Profile
  
  def PrintModelAnalysis(graph, run_meta, op_log, command, options):
      return _pywrap_tensorflow_internal.PrintModelAnalysis(graph, run_meta, op_log, command, options)
  PrintModelAnalysis = _pywrap_tensorflow_internal.PrintModelAnalysis
  
  def InitializePyTrampoline(trampoline):
      return _pywrap_tensorflow_internal.InitializePyTrampoline(trampoline)
  InitializePyTrampoline = _pywrap_tensorflow_internal.InitializePyTrampoline
  class PyRecordReader(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, PyRecordReader, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, PyRecordReader, name)
  
      def __init__(self, *args, **kwargs):
          raise AttributeError("No constructor defined")
      __repr__ = _swig_repr
      if _newclass:
          New = staticmethod(_pywrap_tensorflow_internal.PyRecordReader_New)
      else:
          New = _pywrap_tensorflow_internal.PyRecordReader_New
      __swig_destroy__ = _pywrap_tensorflow_internal.delete_PyRecordReader
      __del__ = lambda self: None
  
      def GetNext(self, status):
          return _pywrap_tensorflow_internal.PyRecordReader_GetNext(self, status)
  
      def record(self):
          return _pywrap_tensorflow_internal.PyRecordReader_record(self)
  
      def offset(self):
          return _pywrap_tensorflow_internal.PyRecordReader_offset(self)
  
      def Close(self):
          return _pywrap_tensorflow_internal.PyRecordReader_Close(self)
  PyRecordReader_swigregister = _pywrap_tensorflow_internal.PyRecordReader_swigregister
  PyRecordReader_swigregister(PyRecordReader)
  
  def PyRecordReader_New(filename, start_offset, compression_type_string, out_status):
      return _pywrap_tensorflow_internal.PyRecordReader_New(filename, start_offset, compression_type_string, out_status)
  PyRecordReader_New = _pywrap_tensorflow_internal.PyRecordReader_New
  
  class PyRecordWriter(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, PyRecordWriter, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, PyRecordWriter, name)
  
      def __init__(self, *args, **kwargs):
          raise AttributeError("No constructor defined")
      __repr__ = _swig_repr
      if _newclass:
          New = staticmethod(_pywrap_tensorflow_internal.PyRecordWriter_New)
      else:
          New = _pywrap_tensorflow_internal.PyRecordWriter_New
      __swig_destroy__ = _pywrap_tensorflow_internal.delete_PyRecordWriter
      __del__ = lambda self: None
  
      def WriteRecord(self, record):
          return _pywrap_tensorflow_internal.PyRecordWriter_WriteRecord(self, record)
  
      def Flush(self, out_status):
          return _pywrap_tensorflow_internal.PyRecordWriter_Flush(self, out_status)
  
      def Close(self, out_status):
          return _pywrap_tensorflow_internal.PyRecordWriter_Close(self, out_status)
  PyRecordWriter_swigregister = _pywrap_tensorflow_internal.PyRecordWriter_swigregister
  PyRecordWriter_swigregister(PyRecordWriter)
  
  def PyRecordWriter_New(filename, compression_type_string, out_status):
      return _pywrap_tensorflow_internal.PyRecordWriter_New(filename, compression_type_string, out_status)
  PyRecordWriter_New = _pywrap_tensorflow_internal.PyRecordWriter_New
  
  class EventsWriter(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, EventsWriter, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, EventsWriter, name)
      __repr__ = _swig_repr
  
      def __init__(self, file_prefix):
          this = _pywrap_tensorflow_internal.new_EventsWriter(file_prefix)
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
      __swig_destroy__ = _pywrap_tensorflow_internal.delete_EventsWriter
      __del__ = lambda self: None
  
      def InitWithSuffix(self, suffix):
          return _pywrap_tensorflow_internal.EventsWriter_InitWithSuffix(self, suffix)
  
      def FileName(self):
          return _pywrap_tensorflow_internal.EventsWriter_FileName(self)
  
      def _WriteSerializedEvent(self, event_str):
          return _pywrap_tensorflow_internal.EventsWriter__WriteSerializedEvent(self, event_str)
  
      def Flush(self):
          return _pywrap_tensorflow_internal.EventsWriter_Flush(self)
  
      def Close(self):
          return _pywrap_tensorflow_internal.EventsWriter_Close(self)
  
      def WriteEvent(self, event):
        from tensorflow.core.util.event_pb2 import Event
        if not isinstance(event, Event):
          raise TypeError("Expected an event_pb2.Event proto, "
                          " but got %s" % type(event))
        return self._WriteSerializedEvent(event.SerializeToString())
  
  EventsWriter_swigregister = _pywrap_tensorflow_internal.EventsWriter_swigregister
  EventsWriter_swigregister(EventsWriter)
  
  __version__ = _pywrap_tensorflow_internal.__version__
  GRAPH_DEF_VERSION = _pywrap_tensorflow_internal.GRAPH_DEF_VERSION
  GRAPH_DEF_VERSION_MIN_CONSUMER = _pywrap_tensorflow_internal.GRAPH_DEF_VERSION_MIN_CONSUMER
  GRAPH_DEF_VERSION_MIN_PRODUCER = _pywrap_tensorflow_internal.GRAPH_DEF_VERSION_MIN_PRODUCER
  __git_version__ = _pywrap_tensorflow_internal.__git_version__
  __compiler_version__ = _pywrap_tensorflow_internal.__compiler_version__
  TENSOR_HANDLE_KEY = _pywrap_tensorflow_internal.TENSOR_HANDLE_KEY
  
  def PyTensorListToVector(py_tensor_list, vec, error_msg):
      return _pywrap_tensorflow_internal.PyTensorListToVector(py_tensor_list, vec, error_msg)
  PyTensorListToVector = _pywrap_tensorflow_internal.PyTensorListToVector
  
  def TF_Version():
      return _pywrap_tensorflow_internal.TF_Version()
  TF_Version = _pywrap_tensorflow_internal.TF_Version
  TF_FLOAT = _pywrap_tensorflow_internal.TF_FLOAT
  TF_DOUBLE = _pywrap_tensorflow_internal.TF_DOUBLE
  TF_INT32 = _pywrap_tensorflow_internal.TF_INT32
  TF_UINT8 = _pywrap_tensorflow_internal.TF_UINT8
  TF_INT16 = _pywrap_tensorflow_internal.TF_INT16
  TF_INT8 = _pywrap_tensorflow_internal.TF_INT8
  TF_STRING = _pywrap_tensorflow_internal.TF_STRING
  TF_COMPLEX64 = _pywrap_tensorflow_internal.TF_COMPLEX64
  TF_COMPLEX = _pywrap_tensorflow_internal.TF_COMPLEX
  TF_INT64 = _pywrap_tensorflow_internal.TF_INT64
  TF_BOOL = _pywrap_tensorflow_internal.TF_BOOL
  TF_QINT8 = _pywrap_tensorflow_internal.TF_QINT8
  TF_QUINT8 = _pywrap_tensorflow_internal.TF_QUINT8
  TF_QINT32 = _pywrap_tensorflow_internal.TF_QINT32
  TF_BFLOAT16 = _pywrap_tensorflow_internal.TF_BFLOAT16
  TF_QINT16 = _pywrap_tensorflow_internal.TF_QINT16
  TF_QUINT16 = _pywrap_tensorflow_internal.TF_QUINT16
  TF_UINT16 = _pywrap_tensorflow_internal.TF_UINT16
  TF_COMPLEX128 = _pywrap_tensorflow_internal.TF_COMPLEX128
  TF_HALF = _pywrap_tensorflow_internal.TF_HALF
  TF_RESOURCE = _pywrap_tensorflow_internal.TF_RESOURCE
  TF_VARIANT = _pywrap_tensorflow_internal.TF_VARIANT
  
  def TF_DataTypeSize(dt):
      return _pywrap_tensorflow_internal.TF_DataTypeSize(dt)
  TF_DataTypeSize = _pywrap_tensorflow_internal.TF_DataTypeSize
  TF_OK = _pywrap_tensorflow_internal.TF_OK
  TF_CANCELLED = _pywrap_tensorflow_internal.TF_CANCELLED
  TF_UNKNOWN = _pywrap_tensorflow_internal.TF_UNKNOWN
  TF_INVALID_ARGUMENT = _pywrap_tensorflow_internal.TF_INVALID_ARGUMENT
  TF_DEADLINE_EXCEEDED = _pywrap_tensorflow_internal.TF_DEADLINE_EXCEEDED
  TF_NOT_FOUND = _pywrap_tensorflow_internal.TF_NOT_FOUND
  TF_ALREADY_EXISTS = _pywrap_tensorflow_internal.TF_ALREADY_EXISTS
  TF_PERMISSION_DENIED = _pywrap_tensorflow_internal.TF_PERMISSION_DENIED
  TF_UNAUTHENTICATED = _pywrap_tensorflow_internal.TF_UNAUTHENTICATED
  TF_RESOURCE_EXHAUSTED = _pywrap_tensorflow_internal.TF_RESOURCE_EXHAUSTED
  TF_FAILED_PRECONDITION = _pywrap_tensorflow_internal.TF_FAILED_PRECONDITION
  TF_ABORTED = _pywrap_tensorflow_internal.TF_ABORTED
  TF_OUT_OF_RANGE = _pywrap_tensorflow_internal.TF_OUT_OF_RANGE
  TF_UNIMPLEMENTED = _pywrap_tensorflow_internal.TF_UNIMPLEMENTED
  TF_INTERNAL = _pywrap_tensorflow_internal.TF_INTERNAL
  TF_UNAVAILABLE = _pywrap_tensorflow_internal.TF_UNAVAILABLE
  TF_DATA_LOSS = _pywrap_tensorflow_internal.TF_DATA_LOSS
  
  def TF_NewStatus():
      return _pywrap_tensorflow_internal.TF_NewStatus()
  TF_NewStatus = _pywrap_tensorflow_internal.TF_NewStatus
  
  def TF_DeleteStatus(arg1):
      return _pywrap_tensorflow_internal.TF_DeleteStatus(arg1)
  TF_DeleteStatus = _pywrap_tensorflow_internal.TF_DeleteStatus
  
  def TF_SetStatus(s, code, msg):
      return _pywrap_tensorflow_internal.TF_SetStatus(s, code, msg)
  TF_SetStatus = _pywrap_tensorflow_internal.TF_SetStatus
  
  def TF_GetCode(s):
      return _pywrap_tensorflow_internal.TF_GetCode(s)
  TF_GetCode = _pywrap_tensorflow_internal.TF_GetCode
  
  def TF_Message(s):
      return _pywrap_tensorflow_internal.TF_Message(s)
  TF_Message = _pywrap_tensorflow_internal.TF_Message
  class TF_Buffer(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, TF_Buffer, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, TF_Buffer, name)
      __repr__ = _swig_repr
      __swig_setmethods__["data"] = _pywrap_tensorflow_internal.TF_Buffer_data_set
      __swig_getmethods__["data"] = _pywrap_tensorflow_internal.TF_Buffer_data_get
      if _newclass:
          data = _swig_property(_pywrap_tensorflow_internal.TF_Buffer_data_get, _pywrap_tensorflow_internal.TF_Buffer_data_set)
      __swig_setmethods__["length"] = _pywrap_tensorflow_internal.TF_Buffer_length_set
      __swig_getmethods__["length"] = _pywrap_tensorflow_internal.TF_Buffer_length_get
      if _newclass:
          length = _swig_property(_pywrap_tensorflow_internal.TF_Buffer_length_get, _pywrap_tensorflow_internal.TF_Buffer_length_set)
      __swig_setmethods__["data_deallocator"] = _pywrap_tensorflow_internal.TF_Buffer_data_deallocator_set
      __swig_getmethods__["data_deallocator"] = _pywrap_tensorflow_internal.TF_Buffer_data_deallocator_get
      if _newclass:
          data_deallocator = _swig_property(_pywrap_tensorflow_internal.TF_Buffer_data_deallocator_get, _pywrap_tensorflow_internal.TF_Buffer_data_deallocator_set)
  
      def __init__(self):
          this = _pywrap_tensorflow_internal.new_TF_Buffer()
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
      __swig_destroy__ = _pywrap_tensorflow_internal.delete_TF_Buffer
      __del__ = lambda self: None
  TF_Buffer_swigregister = _pywrap_tensorflow_internal.TF_Buffer_swigregister
  TF_Buffer_swigregister(TF_Buffer)
  
  
  def TF_NewBufferFromString(proto):
      return _pywrap_tensorflow_internal.TF_NewBufferFromString(proto)
  TF_NewBufferFromString = _pywrap_tensorflow_internal.TF_NewBufferFromString
  
  def TF_NewBuffer():
      return _pywrap_tensorflow_internal.TF_NewBuffer()
  TF_NewBuffer = _pywrap_tensorflow_internal.TF_NewBuffer
  
  def TF_DeleteBuffer(arg1):
      return _pywrap_tensorflow_internal.TF_DeleteBuffer(arg1)
  TF_DeleteBuffer = _pywrap_tensorflow_internal.TF_DeleteBuffer
  
  def TF_GetBuffer(buffer):
      return _pywrap_tensorflow_internal.TF_GetBuffer(buffer)
  TF_GetBuffer = _pywrap_tensorflow_internal.TF_GetBuffer
  
  def TF_NewTensor(arg1, dims, num_dims, data, len, deallocator, deallocator_arg):
      return _pywrap_tensorflow_internal.TF_NewTensor(arg1, dims, num_dims, data, len, deallocator, deallocator_arg)
  TF_NewTensor = _pywrap_tensorflow_internal.TF_NewTensor
  
  def TF_AllocateTensor(arg1, dims, num_dims, len):
      return _pywrap_tensorflow_internal.TF_AllocateTensor(arg1, dims, num_dims, len)
  TF_AllocateTensor = _pywrap_tensorflow_internal.TF_AllocateTensor
  
  def TF_TensorMaybeMove(tensor):
      return _pywrap_tensorflow_internal.TF_TensorMaybeMove(tensor)
  TF_TensorMaybeMove = _pywrap_tensorflow_internal.TF_TensorMaybeMove
  
  def TF_DeleteTensor(arg1):
      return _pywrap_tensorflow_internal.TF_DeleteTensor(arg1)
  TF_DeleteTensor = _pywrap_tensorflow_internal.TF_DeleteTensor
  
  def TF_TensorType(arg1):
      return _pywrap_tensorflow_internal.TF_TensorType(arg1)
  TF_TensorType = _pywrap_tensorflow_internal.TF_TensorType
  
  def TF_NumDims(arg1):
      return _pywrap_tensorflow_internal.TF_NumDims(arg1)
  TF_NumDims = _pywrap_tensorflow_internal.TF_NumDims
  
  def TF_Dim(tensor, dim_index):
      return _pywrap_tensorflow_internal.TF_Dim(tensor, dim_index)
  TF_Dim = _pywrap_tensorflow_internal.TF_Dim
  
  def TF_TensorByteSize(arg1):
      return _pywrap_tensorflow_internal.TF_TensorByteSize(arg1)
  TF_TensorByteSize = _pywrap_tensorflow_internal.TF_TensorByteSize
  
  def TF_TensorData(arg1):
      return _pywrap_tensorflow_internal.TF_TensorData(arg1)
  TF_TensorData = _pywrap_tensorflow_internal.TF_TensorData
  
  def TF_StringEncode(src, src_len, dst, dst_len, status):
      return _pywrap_tensorflow_internal.TF_StringEncode(src, src_len, dst, dst_len, status)
  TF_StringEncode = _pywrap_tensorflow_internal.TF_StringEncode
  
  def TF_StringDecode(src, src_len, dst, dst_len, status):
      return _pywrap_tensorflow_internal.TF_StringDecode(src, src_len, dst, dst_len, status)
  TF_StringDecode = _pywrap_tensorflow_internal.TF_StringDecode
  
  def TF_StringEncodedSize(len):
      return _pywrap_tensorflow_internal.TF_StringEncodedSize(len)
  TF_StringEncodedSize = _pywrap_tensorflow_internal.TF_StringEncodedSize
  
  def _TF_NewSessionOptions():
      return _pywrap_tensorflow_internal._TF_NewSessionOptions()
  _TF_NewSessionOptions = _pywrap_tensorflow_internal._TF_NewSessionOptions
  
  def _TF_SetTarget(options, target):
      return _pywrap_tensorflow_internal._TF_SetTarget(options, target)
  _TF_SetTarget = _pywrap_tensorflow_internal._TF_SetTarget
  
  def _TF_SetConfig(options, proto, status):
      return _pywrap_tensorflow_internal._TF_SetConfig(options, proto, status)
  _TF_SetConfig = _pywrap_tensorflow_internal._TF_SetConfig
  
  def TF_DeleteSessionOptions(arg1):
      return _pywrap_tensorflow_internal.TF_DeleteSessionOptions(arg1)
  TF_DeleteSessionOptions = _pywrap_tensorflow_internal.TF_DeleteSessionOptions
  
  def TF_NewGraph():
      return _pywrap_tensorflow_internal.TF_NewGraph()
  TF_NewGraph = _pywrap_tensorflow_internal.TF_NewGraph
  
  def TF_DeleteGraph(arg1):
      return _pywrap_tensorflow_internal.TF_DeleteGraph(arg1)
  TF_DeleteGraph = _pywrap_tensorflow_internal.TF_DeleteGraph
  class TF_Input(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, TF_Input, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, TF_Input, name)
      __repr__ = _swig_repr
      __swig_setmethods__["oper"] = _pywrap_tensorflow_internal.TF_Input_oper_set
      __swig_getmethods__["oper"] = _pywrap_tensorflow_internal.TF_Input_oper_get
      if _newclass:
          oper = _swig_property(_pywrap_tensorflow_internal.TF_Input_oper_get, _pywrap_tensorflow_internal.TF_Input_oper_set)
      __swig_setmethods__["index"] = _pywrap_tensorflow_internal.TF_Input_index_set
      __swig_getmethods__["index"] = _pywrap_tensorflow_internal.TF_Input_index_get
      if _newclass:
          index = _swig_property(_pywrap_tensorflow_internal.TF_Input_index_get, _pywrap_tensorflow_internal.TF_Input_index_set)
  
      def __init__(self):
          this = _pywrap_tensorflow_internal.new_TF_Input()
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
      __swig_destroy__ = _pywrap_tensorflow_internal.delete_TF_Input
      __del__ = lambda self: None
  TF_Input_swigregister = _pywrap_tensorflow_internal.TF_Input_swigregister
  TF_Input_swigregister(TF_Input)
  
  class TF_Output(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, TF_Output, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, TF_Output, name)
      __repr__ = _swig_repr
      __swig_setmethods__["oper"] = _pywrap_tensorflow_internal.TF_Output_oper_set
      __swig_getmethods__["oper"] = _pywrap_tensorflow_internal.TF_Output_oper_get
      if _newclass:
          oper = _swig_property(_pywrap_tensorflow_internal.TF_Output_oper_get, _pywrap_tensorflow_internal.TF_Output_oper_set)
      __swig_setmethods__["index"] = _pywrap_tensorflow_internal.TF_Output_index_set
      __swig_getmethods__["index"] = _pywrap_tensorflow_internal.TF_Output_index_get
      if _newclass:
          index = _swig_property(_pywrap_tensorflow_internal.TF_Output_index_get, _pywrap_tensorflow_internal.TF_Output_index_set)
  
      def __init__(self):
          this = _pywrap_tensorflow_internal.new_TF_Output()
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
      __swig_destroy__ = _pywrap_tensorflow_internal.delete_TF_Output
      __del__ = lambda self: None
  TF_Output_swigregister = _pywrap_tensorflow_internal.TF_Output_swigregister
  TF_Output_swigregister(TF_Output)
  
  
  def TF_GraphSetTensorShape(graph, output, dims, num_dims, status):
      return _pywrap_tensorflow_internal.TF_GraphSetTensorShape(graph, output, dims, num_dims, status)
  TF_GraphSetTensorShape = _pywrap_tensorflow_internal.TF_GraphSetTensorShape
  
  def TF_GraphGetTensorNumDims(graph, output, status):
      return _pywrap_tensorflow_internal.TF_GraphGetTensorNumDims(graph, output, status)
  TF_GraphGetTensorNumDims = _pywrap_tensorflow_internal.TF_GraphGetTensorNumDims
  
  def TF_GraphGetTensorShape(graph, output, dims, num_dims, status):
      return _pywrap_tensorflow_internal.TF_GraphGetTensorShape(graph, output, dims, num_dims, status)
  TF_GraphGetTensorShape = _pywrap_tensorflow_internal.TF_GraphGetTensorShape
  
  def TF_NewOperation(graph, op_type, oper_name):
      return _pywrap_tensorflow_internal.TF_NewOperation(graph, op_type, oper_name)
  TF_NewOperation = _pywrap_tensorflow_internal.TF_NewOperation
  
  def TF_SetDevice(desc, device):
      return _pywrap_tensorflow_internal.TF_SetDevice(desc, device)
  TF_SetDevice = _pywrap_tensorflow_internal.TF_SetDevice
  
  def TF_AddInput(desc, input):
      return _pywrap_tensorflow_internal.TF_AddInput(desc, input)
  TF_AddInput = _pywrap_tensorflow_internal.TF_AddInput
  
  def TF_AddInputList(desc, inputs):
      return _pywrap_tensorflow_internal.TF_AddInputList(desc, inputs)
  TF_AddInputList = _pywrap_tensorflow_internal.TF_AddInputList
  
  def TF_AddControlInput(desc, input):
      return _pywrap_tensorflow_internal.TF_AddControlInput(desc, input)
  TF_AddControlInput = _pywrap_tensorflow_internal.TF_AddControlInput
  
  def TF_ColocateWith(desc, op):
      return _pywrap_tensorflow_internal.TF_ColocateWith(desc, op)
  TF_ColocateWith = _pywrap_tensorflow_internal.TF_ColocateWith
  
  def TF_SetAttrString(desc, attr_name, value, length):
      return _pywrap_tensorflow_internal.TF_SetAttrString(desc, attr_name, value, length)
  TF_SetAttrString = _pywrap_tensorflow_internal.TF_SetAttrString
  
  def TF_SetAttrStringList(desc, attr_name, values, lengths, num_values):
      return _pywrap_tensorflow_internal.TF_SetAttrStringList(desc, attr_name, values, lengths, num_values)
  TF_SetAttrStringList = _pywrap_tensorflow_internal.TF_SetAttrStringList
  
  def TF_SetAttrInt(desc, attr_name, value):
      return _pywrap_tensorflow_internal.TF_SetAttrInt(desc, attr_name, value)
  TF_SetAttrInt = _pywrap_tensorflow_internal.TF_SetAttrInt
  
  def TF_SetAttrIntList(desc, attr_name, values, num_values):
      return _pywrap_tensorflow_internal.TF_SetAttrIntList(desc, attr_name, values, num_values)
  TF_SetAttrIntList = _pywrap_tensorflow_internal.TF_SetAttrIntList
  
  def TF_SetAttrFloat(desc, attr_name, value):
      return _pywrap_tensorflow_internal.TF_SetAttrFloat(desc, attr_name, value)
  TF_SetAttrFloat = _pywrap_tensorflow_internal.TF_SetAttrFloat
  
  def TF_SetAttrFloatList(desc, attr_name, values, num_values):
      return _pywrap_tensorflow_internal.TF_SetAttrFloatList(desc, attr_name, values, num_values)
  TF_SetAttrFloatList = _pywrap_tensorflow_internal.TF_SetAttrFloatList
  
  def TF_SetAttrBool(desc, attr_name, value):
      return _pywrap_tensorflow_internal.TF_SetAttrBool(desc, attr_name, value)
  TF_SetAttrBool = _pywrap_tensorflow_internal.TF_SetAttrBool
  
  def TF_SetAttrBoolList(desc, attr_name, values, num_values):
      return _pywrap_tensorflow_internal.TF_SetAttrBoolList(desc, attr_name, values, num_values)
  TF_SetAttrBoolList = _pywrap_tensorflow_internal.TF_SetAttrBoolList
  
  def TF_SetAttrType(desc, attr_name, value):
      return _pywrap_tensorflow_internal.TF_SetAttrType(desc, attr_name, value)
  TF_SetAttrType = _pywrap_tensorflow_internal.TF_SetAttrType
  
  def TF_SetAttrTypeList(desc, attr_name, values, num_values):
      return _pywrap_tensorflow_internal.TF_SetAttrTypeList(desc, attr_name, values, num_values)
  TF_SetAttrTypeList = _pywrap_tensorflow_internal.TF_SetAttrTypeList
  
  def TF_SetAttrShape(desc, attr_name, dims, num_dims):
      return _pywrap_tensorflow_internal.TF_SetAttrShape(desc, attr_name, dims, num_dims)
  TF_SetAttrShape = _pywrap_tensorflow_internal.TF_SetAttrShape
  
  def TF_SetAttrShapeList(desc, attr_name, dims, num_dims, num_shapes):
      return _pywrap_tensorflow_internal.TF_SetAttrShapeList(desc, attr_name, dims, num_dims, num_shapes)
  TF_SetAttrShapeList = _pywrap_tensorflow_internal.TF_SetAttrShapeList
  
  def TF_SetAttrTensorShapeProto(desc, attr_name, proto, status):
      return _pywrap_tensorflow_internal.TF_SetAttrTensorShapeProto(desc, attr_name, proto, status)
  TF_SetAttrTensorShapeProto = _pywrap_tensorflow_internal.TF_SetAttrTensorShapeProto
  
  def TF_SetAttrTensorShapeProtoList(desc, attr_name, protos, proto_lens, num_shapes, status):
      return _pywrap_tensorflow_internal.TF_SetAttrTensorShapeProtoList(desc, attr_name, protos, proto_lens, num_shapes, status)
  TF_SetAttrTensorShapeProtoList = _pywrap_tensorflow_internal.TF_SetAttrTensorShapeProtoList
  
  def TF_SetAttrTensor(desc, attr_name, value, status):
      return _pywrap_tensorflow_internal.TF_SetAttrTensor(desc, attr_name, value, status)
  TF_SetAttrTensor = _pywrap_tensorflow_internal.TF_SetAttrTensor
  
  def TF_SetAttrTensorList(desc, attr_name, values, num_values, status):
      return _pywrap_tensorflow_internal.TF_SetAttrTensorList(desc, attr_name, values, num_values, status)
  TF_SetAttrTensorList = _pywrap_tensorflow_internal.TF_SetAttrTensorList
  
  def TF_SetAttrValueProto(desc, attr_name, proto, status):
      return _pywrap_tensorflow_internal.TF_SetAttrValueProto(desc, attr_name, proto, status)
  TF_SetAttrValueProto = _pywrap_tensorflow_internal.TF_SetAttrValueProto
  
  def TF_FinishOperation(desc, status):
      return _pywrap_tensorflow_internal.TF_FinishOperation(desc, status)
  TF_FinishOperation = _pywrap_tensorflow_internal.TF_FinishOperation
  
  def TF_OperationName(oper):
      return _pywrap_tensorflow_internal.TF_OperationName(oper)
  TF_OperationName = _pywrap_tensorflow_internal.TF_OperationName
  
  def TF_OperationOpType(oper):
      return _pywrap_tensorflow_internal.TF_OperationOpType(oper)
  TF_OperationOpType = _pywrap_tensorflow_internal.TF_OperationOpType
  
  def TF_OperationDevice(oper):
      return _pywrap_tensorflow_internal.TF_OperationDevice(oper)
  TF_OperationDevice = _pywrap_tensorflow_internal.TF_OperationDevice
  
  def TF_OperationNumOutputs(oper):
      return _pywrap_tensorflow_internal.TF_OperationNumOutputs(oper)
  TF_OperationNumOutputs = _pywrap_tensorflow_internal.TF_OperationNumOutputs
  
  def TF_OperationOutputType(oper_out):
      return _pywrap_tensorflow_internal.TF_OperationOutputType(oper_out)
  TF_OperationOutputType = _pywrap_tensorflow_internal.TF_OperationOutputType
  
  def TF_OperationOutputListLength(oper, arg_name, status):
      return _pywrap_tensorflow_internal.TF_OperationOutputListLength(oper, arg_name, status)
  TF_OperationOutputListLength = _pywrap_tensorflow_internal.TF_OperationOutputListLength
  
  def TF_OperationNumInputs(oper):
      return _pywrap_tensorflow_internal.TF_OperationNumInputs(oper)
  TF_OperationNumInputs = _pywrap_tensorflow_internal.TF_OperationNumInputs
  
  def TF_OperationInputType(oper_in):
      return _pywrap_tensorflow_internal.TF_OperationInputType(oper_in)
  TF_OperationInputType = _pywrap_tensorflow_internal.TF_OperationInputType
  
  def TF_OperationInputListLength(oper, arg_name, status):
      return _pywrap_tensorflow_internal.TF_OperationInputListLength(oper, arg_name, status)
  TF_OperationInputListLength = _pywrap_tensorflow_internal.TF_OperationInputListLength
  
  def TF_OperationInput(oper_in):
      return _pywrap_tensorflow_internal.TF_OperationInput(oper_in)
  TF_OperationInput = _pywrap_tensorflow_internal.TF_OperationInput
  
  def TF_OperationOutputNumConsumers(oper_out):
      return _pywrap_tensorflow_internal.TF_OperationOutputNumConsumers(oper_out)
  TF_OperationOutputNumConsumers = _pywrap_tensorflow_internal.TF_OperationOutputNumConsumers
  
  def TF_OperationOutputConsumers(oper_out, consumers, max_consumers):
      return _pywrap_tensorflow_internal.TF_OperationOutputConsumers(oper_out, consumers, max_consumers)
  TF_OperationOutputConsumers = _pywrap_tensorflow_internal.TF_OperationOutputConsumers
  
  def TF_OperationNumControlInputs(oper):
      return _pywrap_tensorflow_internal.TF_OperationNumControlInputs(oper)
  TF_OperationNumControlInputs = _pywrap_tensorflow_internal.TF_OperationNumControlInputs
  
  def TF_OperationNumControlOutputs(oper):
      return _pywrap_tensorflow_internal.TF_OperationNumControlOutputs(oper)
  TF_OperationNumControlOutputs = _pywrap_tensorflow_internal.TF_OperationNumControlOutputs
  
  def TF_OperationGetControlOutputs(oper, control_outputs, max_control_outputs):
      return _pywrap_tensorflow_internal.TF_OperationGetControlOutputs(oper, control_outputs, max_control_outputs)
  TF_OperationGetControlOutputs = _pywrap_tensorflow_internal.TF_OperationGetControlOutputs
  TF_ATTR_STRING = _pywrap_tensorflow_internal.TF_ATTR_STRING
  TF_ATTR_INT = _pywrap_tensorflow_internal.TF_ATTR_INT
  TF_ATTR_FLOAT = _pywrap_tensorflow_internal.TF_ATTR_FLOAT
  TF_ATTR_BOOL = _pywrap_tensorflow_internal.TF_ATTR_BOOL
  TF_ATTR_TYPE = _pywrap_tensorflow_internal.TF_ATTR_TYPE
  TF_ATTR_SHAPE = _pywrap_tensorflow_internal.TF_ATTR_SHAPE
  TF_ATTR_TENSOR = _pywrap_tensorflow_internal.TF_ATTR_TENSOR
  TF_ATTR_PLACEHOLDER = _pywrap_tensorflow_internal.TF_ATTR_PLACEHOLDER
  TF_ATTR_FUNC = _pywrap_tensorflow_internal.TF_ATTR_FUNC
  class TF_AttrMetadata(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, TF_AttrMetadata, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, TF_AttrMetadata, name)
      __repr__ = _swig_repr
      __swig_setmethods__["is_list"] = _pywrap_tensorflow_internal.TF_AttrMetadata_is_list_set
      __swig_getmethods__["is_list"] = _pywrap_tensorflow_internal.TF_AttrMetadata_is_list_get
      if _newclass:
          is_list = _swig_property(_pywrap_tensorflow_internal.TF_AttrMetadata_is_list_get, _pywrap_tensorflow_internal.TF_AttrMetadata_is_list_set)
      __swig_setmethods__["list_size"] = _pywrap_tensorflow_internal.TF_AttrMetadata_list_size_set
      __swig_getmethods__["list_size"] = _pywrap_tensorflow_internal.TF_AttrMetadata_list_size_get
      if _newclass:
          list_size = _swig_property(_pywrap_tensorflow_internal.TF_AttrMetadata_list_size_get, _pywrap_tensorflow_internal.TF_AttrMetadata_list_size_set)
      __swig_setmethods__["type"] = _pywrap_tensorflow_internal.TF_AttrMetadata_type_set
      __swig_getmethods__["type"] = _pywrap_tensorflow_internal.TF_AttrMetadata_type_get
      if _newclass:
          type = _swig_property(_pywrap_tensorflow_internal.TF_AttrMetadata_type_get, _pywrap_tensorflow_internal.TF_AttrMetadata_type_set)
      __swig_setmethods__["total_size"] = _pywrap_tensorflow_internal.TF_AttrMetadata_total_size_set
      __swig_getmethods__["total_size"] = _pywrap_tensorflow_internal.TF_AttrMetadata_total_size_get
      if _newclass:
          total_size = _swig_property(_pywrap_tensorflow_internal.TF_AttrMetadata_total_size_get, _pywrap_tensorflow_internal.TF_AttrMetadata_total_size_set)
  
      def __init__(self):
          this = _pywrap_tensorflow_internal.new_TF_AttrMetadata()
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
      __swig_destroy__ = _pywrap_tensorflow_internal.delete_TF_AttrMetadata
      __del__ = lambda self: None
  TF_AttrMetadata_swigregister = _pywrap_tensorflow_internal.TF_AttrMetadata_swigregister
  TF_AttrMetadata_swigregister(TF_AttrMetadata)
  
  
  def TF_OperationGetAttrMetadata(oper, attr_name, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrMetadata(oper, attr_name, status)
  TF_OperationGetAttrMetadata = _pywrap_tensorflow_internal.TF_OperationGetAttrMetadata
  
  def TF_OperationGetAttrString(oper, attr_name, value, max_length, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrString(oper, attr_name, value, max_length, status)
  TF_OperationGetAttrString = _pywrap_tensorflow_internal.TF_OperationGetAttrString
  
  def TF_OperationGetAttrStringList(oper, attr_name, values, lengths, max_values, storage, storage_size, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrStringList(oper, attr_name, values, lengths, max_values, storage, storage_size, status)
  TF_OperationGetAttrStringList = _pywrap_tensorflow_internal.TF_OperationGetAttrStringList
  
  def TF_OperationGetAttrInt(oper, attr_name, value, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrInt(oper, attr_name, value, status)
  TF_OperationGetAttrInt = _pywrap_tensorflow_internal.TF_OperationGetAttrInt
  
  def TF_OperationGetAttrIntList(oper, attr_name, values, max_values, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrIntList(oper, attr_name, values, max_values, status)
  TF_OperationGetAttrIntList = _pywrap_tensorflow_internal.TF_OperationGetAttrIntList
  
  def TF_OperationGetAttrFloat(oper, attr_name, value, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrFloat(oper, attr_name, value, status)
  TF_OperationGetAttrFloat = _pywrap_tensorflow_internal.TF_OperationGetAttrFloat
  
  def TF_OperationGetAttrFloatList(oper, attr_name, values, max_values, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrFloatList(oper, attr_name, values, max_values, status)
  TF_OperationGetAttrFloatList = _pywrap_tensorflow_internal.TF_OperationGetAttrFloatList
  
  def TF_OperationGetAttrBool(oper, attr_name, value, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrBool(oper, attr_name, value, status)
  TF_OperationGetAttrBool = _pywrap_tensorflow_internal.TF_OperationGetAttrBool
  
  def TF_OperationGetAttrBoolList(oper, attr_name, values, max_values, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrBoolList(oper, attr_name, values, max_values, status)
  TF_OperationGetAttrBoolList = _pywrap_tensorflow_internal.TF_OperationGetAttrBoolList
  
  def TF_OperationGetAttrType(oper, attr_name, value, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrType(oper, attr_name, value, status)
  TF_OperationGetAttrType = _pywrap_tensorflow_internal.TF_OperationGetAttrType
  
  def TF_OperationGetAttrTypeList(oper, attr_name, values, max_values, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrTypeList(oper, attr_name, values, max_values, status)
  TF_OperationGetAttrTypeList = _pywrap_tensorflow_internal.TF_OperationGetAttrTypeList
  
  def TF_OperationGetAttrShape(oper, attr_name, value, num_dims, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrShape(oper, attr_name, value, num_dims, status)
  TF_OperationGetAttrShape = _pywrap_tensorflow_internal.TF_OperationGetAttrShape
  
  def TF_OperationGetAttrShapeList(oper, attr_name, dims, num_dims, num_shapes, storage, storage_size, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrShapeList(oper, attr_name, dims, num_dims, num_shapes, storage, storage_size, status)
  TF_OperationGetAttrShapeList = _pywrap_tensorflow_internal.TF_OperationGetAttrShapeList
  
  def TF_OperationGetAttrTensorShapeProto(oper, attr_name, value, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrTensorShapeProto(oper, attr_name, value, status)
  TF_OperationGetAttrTensorShapeProto = _pywrap_tensorflow_internal.TF_OperationGetAttrTensorShapeProto
  
  def TF_OperationGetAttrTensorShapeProtoList(oper, attr_name, values, max_values, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrTensorShapeProtoList(oper, attr_name, values, max_values, status)
  TF_OperationGetAttrTensorShapeProtoList = _pywrap_tensorflow_internal.TF_OperationGetAttrTensorShapeProtoList
  
  def TF_OperationGetAttrTensor(oper, attr_name, value, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrTensor(oper, attr_name, value, status)
  TF_OperationGetAttrTensor = _pywrap_tensorflow_internal.TF_OperationGetAttrTensor
  
  def TF_OperationGetAttrTensorList(oper, attr_name, values, max_values, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrTensorList(oper, attr_name, values, max_values, status)
  TF_OperationGetAttrTensorList = _pywrap_tensorflow_internal.TF_OperationGetAttrTensorList
  
  def TF_OperationGetAttrValueProto(oper, attr_name, output_attr_value, status):
      return _pywrap_tensorflow_internal.TF_OperationGetAttrValueProto(oper, attr_name, output_attr_value, status)
  TF_OperationGetAttrValueProto = _pywrap_tensorflow_internal.TF_OperationGetAttrValueProto
  
  def TF_GraphOperationByName(graph, oper_name):
      return _pywrap_tensorflow_internal.TF_GraphOperationByName(graph, oper_name)
  TF_GraphOperationByName = _pywrap_tensorflow_internal.TF_GraphOperationByName
  
  def TF_GraphNextOperation(graph, pos):
      return _pywrap_tensorflow_internal.TF_GraphNextOperation(graph, pos)
  TF_GraphNextOperation = _pywrap_tensorflow_internal.TF_GraphNextOperation
  
  def TF_GraphToGraphDef(graph, output_graph_def, status):
      return _pywrap_tensorflow_internal.TF_GraphToGraphDef(graph, output_graph_def, status)
  TF_GraphToGraphDef = _pywrap_tensorflow_internal.TF_GraphToGraphDef
  
  def TF_NewImportGraphDefOptions():
      return _pywrap_tensorflow_internal.TF_NewImportGraphDefOptions()
  TF_NewImportGraphDefOptions = _pywrap_tensorflow_internal.TF_NewImportGraphDefOptions
  
  def TF_DeleteImportGraphDefOptions(opts):
      return _pywrap_tensorflow_internal.TF_DeleteImportGraphDefOptions(opts)
  TF_DeleteImportGraphDefOptions = _pywrap_tensorflow_internal.TF_DeleteImportGraphDefOptions
  
  def TF_ImportGraphDefOptionsSetPrefix(opts, prefix):
      return _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsSetPrefix(opts, prefix)
  TF_ImportGraphDefOptionsSetPrefix = _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsSetPrefix
  
  def TF_ImportGraphDefOptionsAddInputMapping(opts, src_name, src_index, dst):
      return _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsAddInputMapping(opts, src_name, src_index, dst)
  TF_ImportGraphDefOptionsAddInputMapping = _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsAddInputMapping
  
  def TF_ImportGraphDefOptionsRemapControlDependency(opts, src_name, dst):
      return _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsRemapControlDependency(opts, src_name, dst)
  TF_ImportGraphDefOptionsRemapControlDependency = _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsRemapControlDependency
  
  def TF_ImportGraphDefOptionsAddControlDependency(opts, oper):
      return _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsAddControlDependency(opts, oper)
  TF_ImportGraphDefOptionsAddControlDependency = _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsAddControlDependency
  
  def TF_ImportGraphDefOptionsAddReturnOutput(opts, oper_name, index):
      return _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsAddReturnOutput(opts, oper_name, index)
  TF_ImportGraphDefOptionsAddReturnOutput = _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsAddReturnOutput
  
  def TF_ImportGraphDefOptionsNumReturnOutputs(opts):
      return _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsNumReturnOutputs(opts)
  TF_ImportGraphDefOptionsNumReturnOutputs = _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsNumReturnOutputs
  
  def TF_GraphImportGraphDefWithReturnOutputs(graph, graph_def, options, return_outputs, num_return_outputs, status):
      return _pywrap_tensorflow_internal.TF_GraphImportGraphDefWithReturnOutputs(graph, graph_def, options, return_outputs, num_return_outputs, status)
  TF_GraphImportGraphDefWithReturnOutputs = _pywrap_tensorflow_internal.TF_GraphImportGraphDefWithReturnOutputs
  
  def TF_GraphImportGraphDef(graph, graph_def, options, status):
      return _pywrap_tensorflow_internal.TF_GraphImportGraphDef(graph, graph_def, options, status)
  TF_GraphImportGraphDef = _pywrap_tensorflow_internal.TF_GraphImportGraphDef
  
  def TF_GraphCopyFunction(g, func, grad, status):
      return _pywrap_tensorflow_internal.TF_GraphCopyFunction(g, func, grad, status)
  TF_GraphCopyFunction = _pywrap_tensorflow_internal.TF_GraphCopyFunction
  
  def TF_OperationToNodeDef(oper, output_node_def, status):
      return _pywrap_tensorflow_internal.TF_OperationToNodeDef(oper, output_node_def, status)
  TF_OperationToNodeDef = _pywrap_tensorflow_internal.TF_OperationToNodeDef
  
  def TF_AddGradients(g, y, ny, x, nx, dx, status, dy):
      return _pywrap_tensorflow_internal.TF_AddGradients(g, y, ny, x, nx, dx, status, dy)
  TF_AddGradients = _pywrap_tensorflow_internal.TF_AddGradients
  
  def TF_GraphToFunction(fn_body, fn_name, append_hash_to_fn_name, num_opers, opers, ninputs, inputs, noutputs, outputs, output_names, opts, description, status):
      return _pywrap_tensorflow_internal.TF_GraphToFunction(fn_body, fn_name, append_hash_to_fn_name, num_opers, opers, ninputs, inputs, noutputs, outputs, output_names, opts, description, status)
  TF_GraphToFunction = _pywrap_tensorflow_internal.TF_GraphToFunction
  
  def TF_FunctionToFunctionDef(func, output_func_def, status):
      return _pywrap_tensorflow_internal.TF_FunctionToFunctionDef(func, output_func_def, status)
  TF_FunctionToFunctionDef = _pywrap_tensorflow_internal.TF_FunctionToFunctionDef
  
  def TF_FunctionImportFunctionDef(proto, status):
      return _pywrap_tensorflow_internal.TF_FunctionImportFunctionDef(proto, status)
  TF_FunctionImportFunctionDef = _pywrap_tensorflow_internal.TF_FunctionImportFunctionDef
  
  def TF_FunctionSetAttrValueProto(func, attr_name, proto, status):
      return _pywrap_tensorflow_internal.TF_FunctionSetAttrValueProto(func, attr_name, proto, status)
  TF_FunctionSetAttrValueProto = _pywrap_tensorflow_internal.TF_FunctionSetAttrValueProto
  
  def TF_FunctionGetAttrValueProto(func, attr_name, output_attr_value, status):
      return _pywrap_tensorflow_internal.TF_FunctionGetAttrValueProto(func, attr_name, output_attr_value, status)
  TF_FunctionGetAttrValueProto = _pywrap_tensorflow_internal.TF_FunctionGetAttrValueProto
  
  def TF_DeleteFunction(func):
      return _pywrap_tensorflow_internal.TF_DeleteFunction(func)
  TF_DeleteFunction = _pywrap_tensorflow_internal.TF_DeleteFunction
  
  def TF_NewSession(graph, opts, status):
      return _pywrap_tensorflow_internal.TF_NewSession(graph, opts, status)
  TF_NewSession = _pywrap_tensorflow_internal.TF_NewSession
  
  def TF_LoadSessionFromSavedModel(session_options, run_options, export_dir, tags, tags_len, graph, meta_graph_def, status):
      return _pywrap_tensorflow_internal.TF_LoadSessionFromSavedModel(session_options, run_options, export_dir, tags, tags_len, graph, meta_graph_def, status)
  TF_LoadSessionFromSavedModel = _pywrap_tensorflow_internal.TF_LoadSessionFromSavedModel
  
  def TF_CloseSession(arg1, status):
      return _pywrap_tensorflow_internal.TF_CloseSession(arg1, status)
  TF_CloseSession = _pywrap_tensorflow_internal.TF_CloseSession
  
  def TF_DeleteSession(arg1, status):
      return _pywrap_tensorflow_internal.TF_DeleteSession(arg1, status)
  TF_DeleteSession = _pywrap_tensorflow_internal.TF_DeleteSession
  
  def TF_DeletePRunHandle(handle):
      return _pywrap_tensorflow_internal.TF_DeletePRunHandle(handle)
  TF_DeletePRunHandle = _pywrap_tensorflow_internal.TF_DeletePRunHandle
  
  def TF_NewDeprecatedSession(arg1, status):
      return _pywrap_tensorflow_internal.TF_NewDeprecatedSession(arg1, status)
  TF_NewDeprecatedSession = _pywrap_tensorflow_internal.TF_NewDeprecatedSession
  
  def TF_CloseDeprecatedSession(arg1, status):
      return _pywrap_tensorflow_internal.TF_CloseDeprecatedSession(arg1, status)
  TF_CloseDeprecatedSession = _pywrap_tensorflow_internal.TF_CloseDeprecatedSession
  
  def TF_DeleteDeprecatedSession(arg1, status):
      return _pywrap_tensorflow_internal.TF_DeleteDeprecatedSession(arg1, status)
  TF_DeleteDeprecatedSession = _pywrap_tensorflow_internal.TF_DeleteDeprecatedSession
  
  def TF_Reset(opt, containers, ncontainers, status):
      return _pywrap_tensorflow_internal.TF_Reset(opt, containers, ncontainers, status)
  TF_Reset = _pywrap_tensorflow_internal.TF_Reset
  
  def TF_ExtendGraph(arg1, proto, arg3):
      return _pywrap_tensorflow_internal.TF_ExtendGraph(arg1, proto, arg3)
  TF_ExtendGraph = _pywrap_tensorflow_internal.TF_ExtendGraph
  
  def TF_SessionListDevices(session, status):
      return _pywrap_tensorflow_internal.TF_SessionListDevices(session, status)
  TF_SessionListDevices = _pywrap_tensorflow_internal.TF_SessionListDevices
  
  def TF_DeprecatedSessionListDevices(session, status):
      return _pywrap_tensorflow_internal.TF_DeprecatedSessionListDevices(session, status)
  TF_DeprecatedSessionListDevices = _pywrap_tensorflow_internal.TF_DeprecatedSessionListDevices
  
  def TF_DeleteDeviceList(list):
      return _pywrap_tensorflow_internal.TF_DeleteDeviceList(list)
  TF_DeleteDeviceList = _pywrap_tensorflow_internal.TF_DeleteDeviceList
  
  def TF_DeviceListCount(list):
      return _pywrap_tensorflow_internal.TF_DeviceListCount(list)
  TF_DeviceListCount = _pywrap_tensorflow_internal.TF_DeviceListCount
  
  def TF_DeviceListName(list, index, arg3):
      return _pywrap_tensorflow_internal.TF_DeviceListName(list, index, arg3)
  TF_DeviceListName = _pywrap_tensorflow_internal.TF_DeviceListName
  
  def TF_DeviceListType(list, index, arg3):
      return _pywrap_tensorflow_internal.TF_DeviceListType(list, index, arg3)
  TF_DeviceListType = _pywrap_tensorflow_internal.TF_DeviceListType
  
  def TF_DeviceListMemoryBytes(list, index, arg3):
      return _pywrap_tensorflow_internal.TF_DeviceListMemoryBytes(list, index, arg3)
  TF_DeviceListMemoryBytes = _pywrap_tensorflow_internal.TF_DeviceListMemoryBytes
  
  def TF_LoadLibrary(library_filename, status):
      return _pywrap_tensorflow_internal.TF_LoadLibrary(library_filename, status)
  TF_LoadLibrary = _pywrap_tensorflow_internal.TF_LoadLibrary
  
  def TF_GetOpList(lib_handle):
      return _pywrap_tensorflow_internal.TF_GetOpList(lib_handle)
  TF_GetOpList = _pywrap_tensorflow_internal.TF_GetOpList
  
  def TF_DeleteLibraryHandle(lib_handle):
      return _pywrap_tensorflow_internal.TF_DeleteLibraryHandle(lib_handle)
  TF_DeleteLibraryHandle = _pywrap_tensorflow_internal.TF_DeleteLibraryHandle
  
  def TF_GetAllOpList():
      return _pywrap_tensorflow_internal.TF_GetAllOpList()
  TF_GetAllOpList = _pywrap_tensorflow_internal.TF_GetAllOpList
  
  def AddControlInput(graph, op, input):
      return _pywrap_tensorflow_internal.AddControlInput(graph, op, input)
  AddControlInput = _pywrap_tensorflow_internal.AddControlInput
  
  def SetRequestedDevice(graph, op, device):
      return _pywrap_tensorflow_internal.SetRequestedDevice(graph, op, device)
  SetRequestedDevice = _pywrap_tensorflow_internal.SetRequestedDevice
  
  def UpdateEdge(graph, new_src, dst, status):
      return _pywrap_tensorflow_internal.UpdateEdge(graph, new_src, dst, status)
  UpdateEdge = _pywrap_tensorflow_internal.UpdateEdge
  
  def TF_NewSessionOptions(target=None, config=None):
  # NOTE: target and config are validated in the session constructor.
    opts = _TF_NewSessionOptions()
    if target is not None:
      _TF_SetTarget(opts, target)
    if config is not None:
      from tensorflow.python.framework import errors
      with errors.raise_exception_on_not_ok_status() as status:
        config_str = config.SerializeToString()
        _TF_SetConfig(opts, config_str, status)
    return opts
  
  
  def TF_Reset(target, containers=None, config=None):
    from tensorflow.python.framework import errors
    opts = TF_NewSessionOptions(target=target, config=config)
    try:
      with errors.raise_exception_on_not_ok_status() as status:
        TF_Reset_wrapper(opts, containers, status)
    finally:
      TF_DeleteSessionOptions(opts)
  
  
  def TF_Run(session, run_options, feed_dict, output_names, target_nodes, out_status, run_outputs):
      return _pywrap_tensorflow_internal.TF_Run(session, run_options, feed_dict, output_names, target_nodes, out_status, run_outputs)
  TF_Run = _pywrap_tensorflow_internal.TF_Run
  
  def TF_PRunSetup(session, input_names, output_names, target_nodes, out_status):
      return _pywrap_tensorflow_internal.TF_PRunSetup(session, input_names, output_names, target_nodes, out_status)
  TF_PRunSetup = _pywrap_tensorflow_internal.TF_PRunSetup
  
  def TF_PRun(session, handle, feed_dict, output_names, out_status):
      return _pywrap_tensorflow_internal.TF_PRun(session, handle, feed_dict, output_names, out_status)
  TF_PRun = _pywrap_tensorflow_internal.TF_PRun
  
  def TF_Reset_wrapper(opt, containers, out_status):
      return _pywrap_tensorflow_internal.TF_Reset_wrapper(opt, containers, out_status)
  TF_Reset_wrapper = _pywrap_tensorflow_internal.TF_Reset_wrapper
  
  def EqualGraphDefWrapper(actual, expected):
      return _pywrap_tensorflow_internal.EqualGraphDefWrapper(actual, expected)
  EqualGraphDefWrapper = _pywrap_tensorflow_internal.EqualGraphDefWrapper
  
  def TF_SessionRun_wrapper(session, run_options, inputs, outputs, targets, run_metadata, out_status):
      return _pywrap_tensorflow_internal.TF_SessionRun_wrapper(session, run_options, inputs, outputs, targets, run_metadata, out_status)
  TF_SessionRun_wrapper = _pywrap_tensorflow_internal.TF_SessionRun_wrapper
  
  def TF_SessionPRunSetup_wrapper(session, inputs, outputs, targets, out_status):
      return _pywrap_tensorflow_internal.TF_SessionPRunSetup_wrapper(session, inputs, outputs, targets, out_status)
  TF_SessionPRunSetup_wrapper = _pywrap_tensorflow_internal.TF_SessionPRunSetup_wrapper
  
  def TF_SessionPRun_wrapper(session, handle, inputs, outputs, out_status):
      return _pywrap_tensorflow_internal.TF_SessionPRun_wrapper(session, handle, inputs, outputs, out_status)
  TF_SessionPRun_wrapper = _pywrap_tensorflow_internal.TF_SessionPRun_wrapper
  
  def GetOperationInputs(oper):
      return _pywrap_tensorflow_internal.GetOperationInputs(oper)
  GetOperationInputs = _pywrap_tensorflow_internal.GetOperationInputs
  
  def TF_OperationGetControlInputs_wrapper(oper):
      return _pywrap_tensorflow_internal.TF_OperationGetControlInputs_wrapper(oper)
  TF_OperationGetControlInputs_wrapper = _pywrap_tensorflow_internal.TF_OperationGetControlInputs_wrapper
  
  def TF_GraphToFunction_wrapper(fn_body, fn_name, append_hash_to_fn_name, opers, inputs, outputs, output_names, opts, description, out_status):
      return _pywrap_tensorflow_internal.TF_GraphToFunction_wrapper(fn_body, fn_name, append_hash_to_fn_name, opers, inputs, outputs, output_names, opts, description, out_status)
  TF_GraphToFunction_wrapper = _pywrap_tensorflow_internal.TF_GraphToFunction_wrapper
  
  def ListDevices(out_status):
      return _pywrap_tensorflow_internal.ListDevices(out_status)
  ListDevices = _pywrap_tensorflow_internal.ListDevices
  
  def list_devices():
    from tensorflow.python.framework import errors
  
    with errors.raise_exception_on_not_ok_status() as status:
      return ListDevices(status)
  
  
  def FileExists(filename, out_status):
      return _pywrap_tensorflow_internal.FileExists(filename, out_status)
  FileExists = _pywrap_tensorflow_internal.FileExists
  
  def DeleteFile(filename, out_status):
      return _pywrap_tensorflow_internal.DeleteFile(filename, out_status)
  DeleteFile = _pywrap_tensorflow_internal.DeleteFile
  
  def ReadFileToString(filename, out_status):
      return _pywrap_tensorflow_internal.ReadFileToString(filename, out_status)
  ReadFileToString = _pywrap_tensorflow_internal.ReadFileToString
  
  def WriteStringToFile(filename, file_content, out_status):
      return _pywrap_tensorflow_internal.WriteStringToFile(filename, file_content, out_status)
  WriteStringToFile = _pywrap_tensorflow_internal.WriteStringToFile
  
  def GetChildren(dir, out_status):
      return _pywrap_tensorflow_internal.GetChildren(dir, out_status)
  GetChildren = _pywrap_tensorflow_internal.GetChildren
  
  def GetMatchingFiles(filename, out_status):
      return _pywrap_tensorflow_internal.GetMatchingFiles(filename, out_status)
  GetMatchingFiles = _pywrap_tensorflow_internal.GetMatchingFiles
  
  def CreateDir(dirname, out_status):
      return _pywrap_tensorflow_internal.CreateDir(dirname, out_status)
  CreateDir = _pywrap_tensorflow_internal.CreateDir
  
  def RecursivelyCreateDir(dirname, out_status):
      return _pywrap_tensorflow_internal.RecursivelyCreateDir(dirname, out_status)
  RecursivelyCreateDir = _pywrap_tensorflow_internal.RecursivelyCreateDir
  
  def CopyFile(oldpath, newpath, overwrite, out_status):
      return _pywrap_tensorflow_internal.CopyFile(oldpath, newpath, overwrite, out_status)
  CopyFile = _pywrap_tensorflow_internal.CopyFile
  
  def RenameFile(oldname, newname, overwrite, out_status):
      return _pywrap_tensorflow_internal.RenameFile(oldname, newname, overwrite, out_status)
  RenameFile = _pywrap_tensorflow_internal.RenameFile
  
  def DeleteRecursively(dirname, out_status):
      return _pywrap_tensorflow_internal.DeleteRecursively(dirname, out_status)
  DeleteRecursively = _pywrap_tensorflow_internal.DeleteRecursively
  
  def IsDirectory(dirname, out_status):
      return _pywrap_tensorflow_internal.IsDirectory(dirname, out_status)
  IsDirectory = _pywrap_tensorflow_internal.IsDirectory
  
  def Stat(filename, stats, out_status):
      return _pywrap_tensorflow_internal.Stat(filename, stats, out_status)
  Stat = _pywrap_tensorflow_internal.Stat
  
  def CreateBufferedInputStream(filename, buffer_size, out_status):
      return _pywrap_tensorflow_internal.CreateBufferedInputStream(filename, buffer_size, out_status)
  CreateBufferedInputStream = _pywrap_tensorflow_internal.CreateBufferedInputStream
  
  def CreateWritableFile(filename, mode, out_status):
      return _pywrap_tensorflow_internal.CreateWritableFile(filename, mode, out_status)
  CreateWritableFile = _pywrap_tensorflow_internal.CreateWritableFile
  
  def AppendToFile(file_content, file, out_status):
      return _pywrap_tensorflow_internal.AppendToFile(file_content, file, out_status)
  AppendToFile = _pywrap_tensorflow_internal.AppendToFile
  
  def ReadFromStream(stream, bytes, out_status):
      return _pywrap_tensorflow_internal.ReadFromStream(stream, bytes, out_status)
  ReadFromStream = _pywrap_tensorflow_internal.ReadFromStream
  class Status(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, Status, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, Status, name)
      __repr__ = _swig_repr
  
      def __init__(self, *args):
          this = _pywrap_tensorflow_internal.new_Status(*args)
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
      if _newclass:
          OK = staticmethod(_pywrap_tensorflow_internal.Status_OK)
      else:
          OK = _pywrap_tensorflow_internal.Status_OK
  
      def ok(self):
          return _pywrap_tensorflow_internal.Status_ok(self)
  
      def code(self):
          return _pywrap_tensorflow_internal.Status_code(self)
  
      def error_message(self):
          return _pywrap_tensorflow_internal.Status_error_message(self)
  
      def __eq__(self, x):
          return _pywrap_tensorflow_internal.Status___eq__(self, x)
  
      def __ne__(self, x):
          return _pywrap_tensorflow_internal.Status___ne__(self, x)
  
      def Update(self, new_status):
          return _pywrap_tensorflow_internal.Status_Update(self, new_status)
  
      def ToString(self):
          return _pywrap_tensorflow_internal.Status_ToString(self)
  
      def IgnoreError(self):
          return _pywrap_tensorflow_internal.Status_IgnoreError(self)
      __swig_destroy__ = _pywrap_tensorflow_internal.delete_Status
      __del__ = lambda self: None
  Status_swigregister = _pywrap_tensorflow_internal.Status_swigregister
  Status_swigregister(Status)
  
  def Status_OK():
      return _pywrap_tensorflow_internal.Status_OK()
  Status_OK = _pywrap_tensorflow_internal.Status_OK
  
  
  def __lshift__(os, x):
      return _pywrap_tensorflow_internal.__lshift__(os, x)
  __lshift__ = _pywrap_tensorflow_internal.__lshift__
  
  def TfCheckOpHelperOutOfLine(v, msg):
      return _pywrap_tensorflow_internal.TfCheckOpHelperOutOfLine(v, msg)
  TfCheckOpHelperOutOfLine = _pywrap_tensorflow_internal.TfCheckOpHelperOutOfLine
  
  def TfCheckOpHelper(v, msg):
      return _pywrap_tensorflow_internal.TfCheckOpHelper(v, msg)
  TfCheckOpHelper = _pywrap_tensorflow_internal.TfCheckOpHelper
  class WritableFile(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, WritableFile, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, WritableFile, name)
  
      def __init__(self, *args, **kwargs):
          raise AttributeError("No constructor defined - class is abstract")
      __repr__ = _swig_repr
      __swig_destroy__ = _pywrap_tensorflow_internal.delete_WritableFile
      __del__ = lambda self: None
  
      def Close(self):
          return _pywrap_tensorflow_internal.WritableFile_Close(self)
  
      def Flush(self):
          return _pywrap_tensorflow_internal.WritableFile_Flush(self)
  WritableFile_swigregister = _pywrap_tensorflow_internal.WritableFile_swigregister
  WritableFile_swigregister(WritableFile)
  
  class BufferedInputStream(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, BufferedInputStream, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, BufferedInputStream, name)
  
      def __init__(self, *args, **kwargs):
          raise AttributeError("No constructor defined")
      __repr__ = _swig_repr
      __swig_destroy__ = _pywrap_tensorflow_internal.delete_BufferedInputStream
      __del__ = lambda self: None
  
      def Tell(self):
          return _pywrap_tensorflow_internal.BufferedInputStream_Tell(self)
  
      def Seek(self, position):
          return _pywrap_tensorflow_internal.BufferedInputStream_Seek(self, position)
  
      def ReadLineAsString(self):
          return _pywrap_tensorflow_internal.BufferedInputStream_ReadLineAsString(self)
  BufferedInputStream_swigregister = _pywrap_tensorflow_internal.BufferedInputStream_swigregister
  BufferedInputStream_swigregister(BufferedInputStream)
  
  
  def Set_TF_Status_from_Status(tf_status, status):
      return _pywrap_tensorflow_internal.Set_TF_Status_from_Status(tf_status, status)
  Set_TF_Status_from_Status = _pywrap_tensorflow_internal.Set_TF_Status_from_Status
  
  def StatusFromTF_Status(tf_status):
      return _pywrap_tensorflow_internal.StatusFromTF_Status(tf_status)
  StatusFromTF_Status = _pywrap_tensorflow_internal.StatusFromTF_Status
  
  def IsAbsolutePath(path):
      return _pywrap_tensorflow_internal.IsAbsolutePath(path)
  IsAbsolutePath = _pywrap_tensorflow_internal.IsAbsolutePath
  
  def Dirname(path):
      return _pywrap_tensorflow_internal.Dirname(path)
  Dirname = _pywrap_tensorflow_internal.Dirname
  
  def Basename(path):
      return _pywrap_tensorflow_internal.Basename(path)
  Basename = _pywrap_tensorflow_internal.Basename
  
  def Extension(path):
      return _pywrap_tensorflow_internal.Extension(path)
  Extension = _pywrap_tensorflow_internal.Extension
  
  def CleanPath(path):
      return _pywrap_tensorflow_internal.CleanPath(path)
  CleanPath = _pywrap_tensorflow_internal.CleanPath
  
  def ParseURI(uri, scheme, host, path):
      return _pywrap_tensorflow_internal.ParseURI(uri, scheme, host, path)
  ParseURI = _pywrap_tensorflow_internal.ParseURI
  
  def CreateURI(scheme, host, path):
      return _pywrap_tensorflow_internal.CreateURI(scheme, host, path)
  CreateURI = _pywrap_tensorflow_internal.CreateURI
  class FileStatistics(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, FileStatistics, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, FileStatistics, name)
      __repr__ = _swig_repr
      __swig_setmethods__["length"] = _pywrap_tensorflow_internal.FileStatistics_length_set
      __swig_getmethods__["length"] = _pywrap_tensorflow_internal.FileStatistics_length_get
      if _newclass:
          length = _swig_property(_pywrap_tensorflow_internal.FileStatistics_length_get, _pywrap_tensorflow_internal.FileStatistics_length_set)
      __swig_setmethods__["mtime_nsec"] = _pywrap_tensorflow_internal.FileStatistics_mtime_nsec_set
      __swig_getmethods__["mtime_nsec"] = _pywrap_tensorflow_internal.FileStatistics_mtime_nsec_get
      if _newclass:
          mtime_nsec = _swig_property(_pywrap_tensorflow_internal.FileStatistics_mtime_nsec_get, _pywrap_tensorflow_internal.FileStatistics_mtime_nsec_set)
      __swig_setmethods__["is_directory"] = _pywrap_tensorflow_internal.FileStatistics_is_directory_set
      __swig_getmethods__["is_directory"] = _pywrap_tensorflow_internal.FileStatistics_is_directory_get
      if _newclass:
          is_directory = _swig_property(_pywrap_tensorflow_internal.FileStatistics_is_directory_get, _pywrap_tensorflow_internal.FileStatistics_is_directory_set)
  
      def __init__(self, *args):
          this = _pywrap_tensorflow_internal.new_FileStatistics(*args)
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
      __swig_destroy__ = _pywrap_tensorflow_internal.delete_FileStatistics
      __del__ = lambda self: None
  FileStatistics_swigregister = _pywrap_tensorflow_internal.FileStatistics_swigregister
  FileStatistics_swigregister(FileStatistics)
  
  
  def DoQuantizeTrainingOnGraphDefHelper(input_graph, num_bits, out_status):
      return _pywrap_tensorflow_internal.DoQuantizeTrainingOnGraphDefHelper(input_graph, num_bits, out_status)
  DoQuantizeTrainingOnGraphDefHelper = _pywrap_tensorflow_internal.DoQuantizeTrainingOnGraphDefHelper
  
  def do_quantize_training_on_graphdef(input_graph, num_bits):
    from tensorflow.core.framework.graph_pb2 import GraphDef
    from tensorflow.python.framework import errors
    with errors.raise_exception_on_not_ok_status() as status:
      graph = GraphDef()
      result_graph_string = DoQuantizeTrainingOnGraphDefHelper(
          input_graph.SerializeToString(), num_bits, status)
  
    graph.ParseFromString(result_graph_string)
    return graph
  
  
  def PyServer_New(server_def, out_status):
      return _pywrap_tensorflow_internal.PyServer_New(server_def, out_status)
  PyServer_New = _pywrap_tensorflow_internal.PyServer_New
  
  def PyServer_Start(in_server, out_status):
      return _pywrap_tensorflow_internal.PyServer_Start(in_server, out_status)
  PyServer_Start = _pywrap_tensorflow_internal.PyServer_Start
  
  def PyServer_Stop(in_server, out_status):
      return _pywrap_tensorflow_internal.PyServer_Stop(in_server, out_status)
  PyServer_Stop = _pywrap_tensorflow_internal.PyServer_Stop
  
  def PyServer_Join(in_server, out_status):
      return _pywrap_tensorflow_internal.PyServer_Join(in_server, out_status)
  PyServer_Join = _pywrap_tensorflow_internal.PyServer_Join
  class ServerInterface(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, ServerInterface, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, ServerInterface, name)
  
      def __init__(self, *args, **kwargs):
          raise AttributeError("No constructor defined - class is abstract")
      __repr__ = _swig_repr
      __swig_destroy__ = _pywrap_tensorflow_internal.delete_ServerInterface
      __del__ = lambda self: None
  
      def target(self):
          return _pywrap_tensorflow_internal.ServerInterface_target(self)
  ServerInterface_swigregister = _pywrap_tensorflow_internal.ServerInterface_swigregister
  ServerInterface_swigregister(ServerInterface)
  
  
  def GetPythonWrappers(op_list_buf):
      return _pywrap_tensorflow_internal.GetPythonWrappers(op_list_buf)
  GetPythonWrappers = _pywrap_tensorflow_internal.GetPythonWrappers
  
  def RunCppShapeInference(graph_def_version, serialized_node_def, input_serialized_shapes, input_constant_tensor_values, input_constant_tensor_as_shape_values, out_status):
      return _pywrap_tensorflow_internal.RunCppShapeInference(graph_def_version, serialized_node_def, input_serialized_shapes, input_constant_tensor_values, input_constant_tensor_as_shape_values, out_status)
  RunCppShapeInference = _pywrap_tensorflow_internal.RunCppShapeInference
  
  def TryFindKernelClass(serialized_node_def):
      return _pywrap_tensorflow_internal.TryFindKernelClass(serialized_node_def)
  TryFindKernelClass = _pywrap_tensorflow_internal.TryFindKernelClass
  
  def TransformGraphWithStringInputs(graph_def_string, inputs_string, outputs_string, transforms_string, out_status):
      return _pywrap_tensorflow_internal.TransformGraphWithStringInputs(graph_def_string, inputs_string, outputs_string, transforms_string, out_status)
  TransformGraphWithStringInputs = _pywrap_tensorflow_internal.TransformGraphWithStringInputs
  
  def TF_NewCluster(allow_soft_placement, disable_detailed_stats, out_status):
      return _pywrap_tensorflow_internal.TF_NewCluster(allow_soft_placement, disable_detailed_stats, out_status)
  TF_NewCluster = _pywrap_tensorflow_internal.TF_NewCluster
  
  def TF_DeleteCluster(cluster):
      return _pywrap_tensorflow_internal.TF_DeleteCluster(cluster)
  TF_DeleteCluster = _pywrap_tensorflow_internal.TF_DeleteCluster
  
  def TF_MeasureCosts(item, cluster, generate_timeline, out_status):
      return _pywrap_tensorflow_internal.TF_MeasureCosts(item, cluster, generate_timeline, out_status)
  TF_MeasureCosts = _pywrap_tensorflow_internal.TF_MeasureCosts
  
  def TF_NewItem(meta_graph, ignore_colocation, ignore_user_placement, out_status):
      return _pywrap_tensorflow_internal.TF_NewItem(meta_graph, ignore_colocation, ignore_user_placement, out_status)
  TF_NewItem = _pywrap_tensorflow_internal.TF_NewItem
  
  def TF_DeleteItem(item):
      return _pywrap_tensorflow_internal.TF_DeleteItem(item)
  TF_DeleteItem = _pywrap_tensorflow_internal.TF_DeleteItem
  
  def TF_IdentifyImportantOps(item):
      return _pywrap_tensorflow_internal.TF_IdentifyImportantOps(item)
  TF_IdentifyImportantOps = _pywrap_tensorflow_internal.TF_IdentifyImportantOps
  
  def TF_GetOpProperties(item):
      return _pywrap_tensorflow_internal.TF_GetOpProperties(item)
  TF_GetOpProperties = _pywrap_tensorflow_internal.TF_GetOpProperties
  
  def TF_OptimizeGraph(rewriter_config, metagraph, graph_id, out_status):
      return _pywrap_tensorflow_internal.TF_OptimizeGraph(rewriter_config, metagraph, graph_id, out_status)
  TF_OptimizeGraph = _pywrap_tensorflow_internal.TF_OptimizeGraph
  
  def GenerateCostReport(metagraph, per_node_report):
      return _pywrap_tensorflow_internal.GenerateCostReport(metagraph, per_node_report)
  GenerateCostReport = _pywrap_tensorflow_internal.GenerateCostReport
  
  def GenerateModelReport(metagraph):
      return _pywrap_tensorflow_internal.GenerateModelReport(metagraph)
  GenerateModelReport = _pywrap_tensorflow_internal.GenerateModelReport
  # This file is compatible with both classic and new-style classes.
  
  
  