# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# 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
if 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 version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    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 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 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
    __swig_getmethods__["New"] = lambda x: _pywrap_tensorflow_internal.PyRecordReader_New
    if _newclass:
        New = staticmethod(_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
    __swig_getmethods__["New"] = lambda x: _pywrap_tensorflow_internal.PyRecordWriter_New
    if _newclass:
        New = staticmethod(_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 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)


_pywrap_tensorflow_internal.__version___swigconstant(_pywrap_tensorflow_internal)
__version__ = _pywrap_tensorflow_internal.__version__

_pywrap_tensorflow_internal.GRAPH_DEF_VERSION_swigconstant(_pywrap_tensorflow_internal)
GRAPH_DEF_VERSION = _pywrap_tensorflow_internal.GRAPH_DEF_VERSION

_pywrap_tensorflow_internal.GRAPH_DEF_VERSION_MIN_CONSUMER_swigconstant(_pywrap_tensorflow_internal)
GRAPH_DEF_VERSION_MIN_CONSUMER = _pywrap_tensorflow_internal.GRAPH_DEF_VERSION_MIN_CONSUMER

_pywrap_tensorflow_internal.GRAPH_DEF_VERSION_MIN_PRODUCER_swigconstant(_pywrap_tensorflow_internal)
GRAPH_DEF_VERSION_MIN_PRODUCER = _pywrap_tensorflow_internal.GRAPH_DEF_VERSION_MIN_PRODUCER

_pywrap_tensorflow_internal.__git_version___swigconstant(_pywrap_tensorflow_internal)
__git_version__ = _pywrap_tensorflow_internal.__git_version__

_pywrap_tensorflow_internal.__compiler_version___swigconstant(_pywrap_tensorflow_internal)
__compiler_version__ = _pywrap_tensorflow_internal.__compiler_version__

_pywrap_tensorflow_internal.TENSOR_HANDLE_KEY_swigconstant(_pywrap_tensorflow_internal)
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

_pywrap_tensorflow_internal.TF_FLOAT_swigconstant(_pywrap_tensorflow_internal)
TF_FLOAT = _pywrap_tensorflow_internal.TF_FLOAT

_pywrap_tensorflow_internal.TF_DOUBLE_swigconstant(_pywrap_tensorflow_internal)
TF_DOUBLE = _pywrap_tensorflow_internal.TF_DOUBLE

_pywrap_tensorflow_internal.TF_INT32_swigconstant(_pywrap_tensorflow_internal)
TF_INT32 = _pywrap_tensorflow_internal.TF_INT32

_pywrap_tensorflow_internal.TF_UINT8_swigconstant(_pywrap_tensorflow_internal)
TF_UINT8 = _pywrap_tensorflow_internal.TF_UINT8

_pywrap_tensorflow_internal.TF_INT16_swigconstant(_pywrap_tensorflow_internal)
TF_INT16 = _pywrap_tensorflow_internal.TF_INT16

_pywrap_tensorflow_internal.TF_INT8_swigconstant(_pywrap_tensorflow_internal)
TF_INT8 = _pywrap_tensorflow_internal.TF_INT8

_pywrap_tensorflow_internal.TF_STRING_swigconstant(_pywrap_tensorflow_internal)
TF_STRING = _pywrap_tensorflow_internal.TF_STRING

_pywrap_tensorflow_internal.TF_COMPLEX64_swigconstant(_pywrap_tensorflow_internal)
TF_COMPLEX64 = _pywrap_tensorflow_internal.TF_COMPLEX64

_pywrap_tensorflow_internal.TF_COMPLEX_swigconstant(_pywrap_tensorflow_internal)
TF_COMPLEX = _pywrap_tensorflow_internal.TF_COMPLEX

_pywrap_tensorflow_internal.TF_INT64_swigconstant(_pywrap_tensorflow_internal)
TF_INT64 = _pywrap_tensorflow_internal.TF_INT64

_pywrap_tensorflow_internal.TF_BOOL_swigconstant(_pywrap_tensorflow_internal)
TF_BOOL = _pywrap_tensorflow_internal.TF_BOOL

_pywrap_tensorflow_internal.TF_QINT8_swigconstant(_pywrap_tensorflow_internal)
TF_QINT8 = _pywrap_tensorflow_internal.TF_QINT8

_pywrap_tensorflow_internal.TF_QUINT8_swigconstant(_pywrap_tensorflow_internal)
TF_QUINT8 = _pywrap_tensorflow_internal.TF_QUINT8

_pywrap_tensorflow_internal.TF_QINT32_swigconstant(_pywrap_tensorflow_internal)
TF_QINT32 = _pywrap_tensorflow_internal.TF_QINT32

_pywrap_tensorflow_internal.TF_BFLOAT16_swigconstant(_pywrap_tensorflow_internal)
TF_BFLOAT16 = _pywrap_tensorflow_internal.TF_BFLOAT16

_pywrap_tensorflow_internal.TF_QINT16_swigconstant(_pywrap_tensorflow_internal)
TF_QINT16 = _pywrap_tensorflow_internal.TF_QINT16

_pywrap_tensorflow_internal.TF_QUINT16_swigconstant(_pywrap_tensorflow_internal)
TF_QUINT16 = _pywrap_tensorflow_internal.TF_QUINT16

_pywrap_tensorflow_internal.TF_UINT16_swigconstant(_pywrap_tensorflow_internal)
TF_UINT16 = _pywrap_tensorflow_internal.TF_UINT16

_pywrap_tensorflow_internal.TF_COMPLEX128_swigconstant(_pywrap_tensorflow_internal)
TF_COMPLEX128 = _pywrap_tensorflow_internal.TF_COMPLEX128

_pywrap_tensorflow_internal.TF_HALF_swigconstant(_pywrap_tensorflow_internal)
TF_HALF = _pywrap_tensorflow_internal.TF_HALF

_pywrap_tensorflow_internal.TF_RESOURCE_swigconstant(_pywrap_tensorflow_internal)
TF_RESOURCE = _pywrap_tensorflow_internal.TF_RESOURCE

_pywrap_tensorflow_internal.TF_VARIANT_swigconstant(_pywrap_tensorflow_internal)
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

_pywrap_tensorflow_internal.TF_OK_swigconstant(_pywrap_tensorflow_internal)
TF_OK = _pywrap_tensorflow_internal.TF_OK

_pywrap_tensorflow_internal.TF_CANCELLED_swigconstant(_pywrap_tensorflow_internal)
TF_CANCELLED = _pywrap_tensorflow_internal.TF_CANCELLED

_pywrap_tensorflow_internal.TF_UNKNOWN_swigconstant(_pywrap_tensorflow_internal)
TF_UNKNOWN = _pywrap_tensorflow_internal.TF_UNKNOWN

_pywrap_tensorflow_internal.TF_INVALID_ARGUMENT_swigconstant(_pywrap_tensorflow_internal)
TF_INVALID_ARGUMENT = _pywrap_tensorflow_internal.TF_INVALID_ARGUMENT

_pywrap_tensorflow_internal.TF_DEADLINE_EXCEEDED_swigconstant(_pywrap_tensorflow_internal)
TF_DEADLINE_EXCEEDED = _pywrap_tensorflow_internal.TF_DEADLINE_EXCEEDED

_pywrap_tensorflow_internal.TF_NOT_FOUND_swigconstant(_pywrap_tensorflow_internal)
TF_NOT_FOUND = _pywrap_tensorflow_internal.TF_NOT_FOUND

_pywrap_tensorflow_internal.TF_ALREADY_EXISTS_swigconstant(_pywrap_tensorflow_internal)
TF_ALREADY_EXISTS = _pywrap_tensorflow_internal.TF_ALREADY_EXISTS

_pywrap_tensorflow_internal.TF_PERMISSION_DENIED_swigconstant(_pywrap_tensorflow_internal)
TF_PERMISSION_DENIED = _pywrap_tensorflow_internal.TF_PERMISSION_DENIED

_pywrap_tensorflow_internal.TF_UNAUTHENTICATED_swigconstant(_pywrap_tensorflow_internal)
TF_UNAUTHENTICATED = _pywrap_tensorflow_internal.TF_UNAUTHENTICATED

_pywrap_tensorflow_internal.TF_RESOURCE_EXHAUSTED_swigconstant(_pywrap_tensorflow_internal)
TF_RESOURCE_EXHAUSTED = _pywrap_tensorflow_internal.TF_RESOURCE_EXHAUSTED

_pywrap_tensorflow_internal.TF_FAILED_PRECONDITION_swigconstant(_pywrap_tensorflow_internal)
TF_FAILED_PRECONDITION = _pywrap_tensorflow_internal.TF_FAILED_PRECONDITION

_pywrap_tensorflow_internal.TF_ABORTED_swigconstant(_pywrap_tensorflow_internal)
TF_ABORTED = _pywrap_tensorflow_internal.TF_ABORTED

_pywrap_tensorflow_internal.TF_OUT_OF_RANGE_swigconstant(_pywrap_tensorflow_internal)
TF_OUT_OF_RANGE = _pywrap_tensorflow_internal.TF_OUT_OF_RANGE

_pywrap_tensorflow_internal.TF_UNIMPLEMENTED_swigconstant(_pywrap_tensorflow_internal)
TF_UNIMPLEMENTED = _pywrap_tensorflow_internal.TF_UNIMPLEMENTED

_pywrap_tensorflow_internal.TF_INTERNAL_swigconstant(_pywrap_tensorflow_internal)
TF_INTERNAL = _pywrap_tensorflow_internal.TF_INTERNAL

_pywrap_tensorflow_internal.TF_UNAVAILABLE_swigconstant(_pywrap_tensorflow_internal)
TF_UNAVAILABLE = _pywrap_tensorflow_internal.TF_UNAVAILABLE

_pywrap_tensorflow_internal.TF_DATA_LOSS_swigconstant(_pywrap_tensorflow_internal)
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 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 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 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

_pywrap_tensorflow_internal.TF_ATTR_STRING_swigconstant(_pywrap_tensorflow_internal)
TF_ATTR_STRING = _pywrap_tensorflow_internal.TF_ATTR_STRING

_pywrap_tensorflow_internal.TF_ATTR_INT_swigconstant(_pywrap_tensorflow_internal)
TF_ATTR_INT = _pywrap_tensorflow_internal.TF_ATTR_INT

_pywrap_tensorflow_internal.TF_ATTR_FLOAT_swigconstant(_pywrap_tensorflow_internal)
TF_ATTR_FLOAT = _pywrap_tensorflow_internal.TF_ATTR_FLOAT

_pywrap_tensorflow_internal.TF_ATTR_BOOL_swigconstant(_pywrap_tensorflow_internal)
TF_ATTR_BOOL = _pywrap_tensorflow_internal.TF_ATTR_BOOL

_pywrap_tensorflow_internal.TF_ATTR_TYPE_swigconstant(_pywrap_tensorflow_internal)
TF_ATTR_TYPE = _pywrap_tensorflow_internal.TF_ATTR_TYPE

_pywrap_tensorflow_internal.TF_ATTR_SHAPE_swigconstant(_pywrap_tensorflow_internal)
TF_ATTR_SHAPE = _pywrap_tensorflow_internal.TF_ATTR_SHAPE

_pywrap_tensorflow_internal.TF_ATTR_TENSOR_swigconstant(_pywrap_tensorflow_internal)
TF_ATTR_TENSOR = _pywrap_tensorflow_internal.TF_ATTR_TENSOR

_pywrap_tensorflow_internal.TF_ATTR_PLACEHOLDER_swigconstant(_pywrap_tensorflow_internal)
TF_ATTR_PLACEHOLDER = _pywrap_tensorflow_internal.TF_ATTR_PLACEHOLDER

_pywrap_tensorflow_internal.TF_ATTR_FUNC_swigconstant(_pywrap_tensorflow_internal)
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 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 Exception:
            self.this = this
    __swig_getmethods__["OK"] = lambda x: _pywrap_tensorflow_internal.Status_OK
    if _newclass:
        OK = staticmethod(_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 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.


