# 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 TF_ListPhysicalDevices():
    return _pywrap_tensorflow_internal.TF_ListPhysicalDevices()
TF_ListPhysicalDevices = _pywrap_tensorflow_internal.TF_ListPhysicalDevices

def TFE_NewContextOptions():
    return _pywrap_tensorflow_internal.TFE_NewContextOptions()
TFE_NewContextOptions = _pywrap_tensorflow_internal.TFE_NewContextOptions

def TFE_ContextOptionsSetConfig(options, proto):
    return _pywrap_tensorflow_internal.TFE_ContextOptionsSetConfig(options, proto)
TFE_ContextOptionsSetConfig = _pywrap_tensorflow_internal.TFE_ContextOptionsSetConfig

_pywrap_tensorflow_internal.TFE_DEVICE_PLACEMENT_EXPLICIT_swigconstant(_pywrap_tensorflow_internal)
TFE_DEVICE_PLACEMENT_EXPLICIT = _pywrap_tensorflow_internal.TFE_DEVICE_PLACEMENT_EXPLICIT

_pywrap_tensorflow_internal.TFE_DEVICE_PLACEMENT_WARN_swigconstant(_pywrap_tensorflow_internal)
TFE_DEVICE_PLACEMENT_WARN = _pywrap_tensorflow_internal.TFE_DEVICE_PLACEMENT_WARN

_pywrap_tensorflow_internal.TFE_DEVICE_PLACEMENT_SILENT_swigconstant(_pywrap_tensorflow_internal)
TFE_DEVICE_PLACEMENT_SILENT = _pywrap_tensorflow_internal.TFE_DEVICE_PLACEMENT_SILENT

_pywrap_tensorflow_internal.TFE_DEVICE_PLACEMENT_SILENT_FOR_INT32_swigconstant(_pywrap_tensorflow_internal)
TFE_DEVICE_PLACEMENT_SILENT_FOR_INT32 = _pywrap_tensorflow_internal.TFE_DEVICE_PLACEMENT_SILENT_FOR_INT32

def TFE_ContextOptionsSetAsync(arg1, enable):
    return _pywrap_tensorflow_internal.TFE_ContextOptionsSetAsync(arg1, enable)
TFE_ContextOptionsSetAsync = _pywrap_tensorflow_internal.TFE_ContextOptionsSetAsync

def TFE_ContextOptionsSetDevicePlacementPolicy(arg1, arg2):
    return _pywrap_tensorflow_internal.TFE_ContextOptionsSetDevicePlacementPolicy(arg1, arg2)
TFE_ContextOptionsSetDevicePlacementPolicy = _pywrap_tensorflow_internal.TFE_ContextOptionsSetDevicePlacementPolicy

def TFE_DeleteContextOptions(arg1):
    return _pywrap_tensorflow_internal.TFE_DeleteContextOptions(arg1)
TFE_DeleteContextOptions = _pywrap_tensorflow_internal.TFE_DeleteContextOptions

def TFE_NewContext(opts):
    return _pywrap_tensorflow_internal.TFE_NewContext(opts)
TFE_NewContext = _pywrap_tensorflow_internal.TFE_NewContext

def TFE_DeleteContext(ctx):
    return _pywrap_tensorflow_internal.TFE_DeleteContext(ctx)
TFE_DeleteContext = _pywrap_tensorflow_internal.TFE_DeleteContext

def TFE_ContextListDevices(ctx):
    return _pywrap_tensorflow_internal.TFE_ContextListDevices(ctx)
TFE_ContextListDevices = _pywrap_tensorflow_internal.TFE_ContextListDevices

def TFE_ContextClearCaches(ctx):
    return _pywrap_tensorflow_internal.TFE_ContextClearCaches(ctx)
TFE_ContextClearCaches = _pywrap_tensorflow_internal.TFE_ContextClearCaches

def TFE_ContextSetThreadLocalDevicePlacementPolicy(arg1, arg2):
    return _pywrap_tensorflow_internal.TFE_ContextSetThreadLocalDevicePlacementPolicy(arg1, arg2)
TFE_ContextSetThreadLocalDevicePlacementPolicy = _pywrap_tensorflow_internal.TFE_ContextSetThreadLocalDevicePlacementPolicy

def TFE_ContextGetDevicePlacementPolicy(arg1):
    return _pywrap_tensorflow_internal.TFE_ContextGetDevicePlacementPolicy(arg1)
TFE_ContextGetDevicePlacementPolicy = _pywrap_tensorflow_internal.TFE_ContextGetDevicePlacementPolicy

def TFE_ContextSetAsyncForThread(arg1, enable):
    return _pywrap_tensorflow_internal.TFE_ContextSetAsyncForThread(arg1, enable)
TFE_ContextSetAsyncForThread = _pywrap_tensorflow_internal.TFE_ContextSetAsyncForThread

def TFE_ContextSetServerDef(ctx, keep_alive_secs, proto):
    return _pywrap_tensorflow_internal.TFE_ContextSetServerDef(ctx, keep_alive_secs, proto)
TFE_ContextSetServerDef = _pywrap_tensorflow_internal.TFE_ContextSetServerDef

def TFE_ContextAsyncWait(arg1):
    return _pywrap_tensorflow_internal.TFE_ContextAsyncWait(arg1)
TFE_ContextAsyncWait = _pywrap_tensorflow_internal.TFE_ContextAsyncWait

def TFE_ContextAsyncClearError(arg1):
    return _pywrap_tensorflow_internal.TFE_ContextAsyncClearError(arg1)
TFE_ContextAsyncClearError = _pywrap_tensorflow_internal.TFE_ContextAsyncClearError

def TFE_OpNameGetAttrType(ctx, op_or_function_name, attr_name):
    return _pywrap_tensorflow_internal.TFE_OpNameGetAttrType(ctx, op_or_function_name, attr_name)
TFE_OpNameGetAttrType = _pywrap_tensorflow_internal.TFE_OpNameGetAttrType

def TFE_ContextAddFunctionDef(ctx, serialized_function_def, size):
    return _pywrap_tensorflow_internal.TFE_ContextAddFunctionDef(ctx, serialized_function_def, size)
TFE_ContextAddFunctionDef = _pywrap_tensorflow_internal.TFE_ContextAddFunctionDef

def TFE_ContextAddFunction(ctx, function):
    return _pywrap_tensorflow_internal.TFE_ContextAddFunction(ctx, function)
TFE_ContextAddFunction = _pywrap_tensorflow_internal.TFE_ContextAddFunction

def TFE_ContextRemoveFunction(ctx, name):
    return _pywrap_tensorflow_internal.TFE_ContextRemoveFunction(ctx, name)
TFE_ContextRemoveFunction = _pywrap_tensorflow_internal.TFE_ContextRemoveFunction

def TFE_ContextHasFunction(ctx, name):
    return _pywrap_tensorflow_internal.TFE_ContextHasFunction(ctx, name)
TFE_ContextHasFunction = _pywrap_tensorflow_internal.TFE_ContextHasFunction

def TFE_ContextEnableRunMetadata(ctx):
    return _pywrap_tensorflow_internal.TFE_ContextEnableRunMetadata(ctx)
TFE_ContextEnableRunMetadata = _pywrap_tensorflow_internal.TFE_ContextEnableRunMetadata

def TFE_ContextDisableRunMetadata(ctx):
    return _pywrap_tensorflow_internal.TFE_ContextDisableRunMetadata(ctx)
TFE_ContextDisableRunMetadata = _pywrap_tensorflow_internal.TFE_ContextDisableRunMetadata

def TFE_ContextExportRunMetadata(ctx, buf):
    return _pywrap_tensorflow_internal.TFE_ContextExportRunMetadata(ctx, buf)
TFE_ContextExportRunMetadata = _pywrap_tensorflow_internal.TFE_ContextExportRunMetadata

def TFE_ContextStartStep(ctx):
    return _pywrap_tensorflow_internal.TFE_ContextStartStep(ctx)
TFE_ContextStartStep = _pywrap_tensorflow_internal.TFE_ContextStartStep

def TFE_ContextEndStep(ctx):
    return _pywrap_tensorflow_internal.TFE_ContextEndStep(ctx)
TFE_ContextEndStep = _pywrap_tensorflow_internal.TFE_ContextEndStep

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_RegisterResourceVariableType(e):
    return _pywrap_tensorflow_internal.TFE_Py_RegisterResourceVariableType(e)
TFE_Py_RegisterResourceVariableType = _pywrap_tensorflow_internal.TFE_Py_RegisterResourceVariableType

def TFE_Py_RegisterVSpace(e):
    return _pywrap_tensorflow_internal.TFE_Py_RegisterVSpace(e)
TFE_Py_RegisterVSpace = _pywrap_tensorflow_internal.TFE_Py_RegisterVSpace

def TFE_Py_RegisterFallbackExceptionClass(e):
    return _pywrap_tensorflow_internal.TFE_Py_RegisterFallbackExceptionClass(e)
TFE_Py_RegisterFallbackExceptionClass = _pywrap_tensorflow_internal.TFE_Py_RegisterFallbackExceptionClass

def TFE_Py_RegisterGradientFunction(e):
    return _pywrap_tensorflow_internal.TFE_Py_RegisterGradientFunction(e)
TFE_Py_RegisterGradientFunction = _pywrap_tensorflow_internal.TFE_Py_RegisterGradientFunction

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 TFE_Py_SetEagerTensorProfiler(profiler):
    return _pywrap_tensorflow_internal.TFE_Py_SetEagerTensorProfiler(profiler)
TFE_Py_SetEagerTensorProfiler = _pywrap_tensorflow_internal.TFE_Py_SetEagerTensorProfiler

def TFE_Py_TapeSetNew(persistent, watch_accessed_variables):
    return _pywrap_tensorflow_internal.TFE_Py_TapeSetNew(persistent, watch_accessed_variables)
TFE_Py_TapeSetNew = _pywrap_tensorflow_internal.TFE_Py_TapeSetNew

def TFE_Py_TapeSetRemove(tape):
    return _pywrap_tensorflow_internal.TFE_Py_TapeSetRemove(tape)
TFE_Py_TapeSetRemove = _pywrap_tensorflow_internal.TFE_Py_TapeSetRemove

def TFE_Py_TapeSetAdd(tape):
    return _pywrap_tensorflow_internal.TFE_Py_TapeSetAdd(tape)
TFE_Py_TapeSetAdd = _pywrap_tensorflow_internal.TFE_Py_TapeSetAdd

def TFE_Py_TapeSetIsEmpty():
    return _pywrap_tensorflow_internal.TFE_Py_TapeSetIsEmpty()
TFE_Py_TapeSetIsEmpty = _pywrap_tensorflow_internal.TFE_Py_TapeSetIsEmpty

def TFE_Py_TapeSetShouldRecord(tensors):
    return _pywrap_tensorflow_internal.TFE_Py_TapeSetShouldRecord(tensors)
TFE_Py_TapeSetShouldRecord = _pywrap_tensorflow_internal.TFE_Py_TapeSetShouldRecord

def TFE_Py_TapeWatch(tape, tensor):
    return _pywrap_tensorflow_internal.TFE_Py_TapeWatch(tape, tensor)
TFE_Py_TapeWatch = _pywrap_tensorflow_internal.TFE_Py_TapeWatch

def TFE_Py_TapeSetDeleteTrace(tensor_id):
    return _pywrap_tensorflow_internal.TFE_Py_TapeSetDeleteTrace(tensor_id)
TFE_Py_TapeSetDeleteTrace = _pywrap_tensorflow_internal.TFE_Py_TapeSetDeleteTrace

def TFE_Py_TapeSetStopOnThread():
    return _pywrap_tensorflow_internal.TFE_Py_TapeSetStopOnThread()
TFE_Py_TapeSetStopOnThread = _pywrap_tensorflow_internal.TFE_Py_TapeSetStopOnThread

def TFE_Py_TapeSetRestartOnThread():
    return _pywrap_tensorflow_internal.TFE_Py_TapeSetRestartOnThread()
TFE_Py_TapeSetRestartOnThread = _pywrap_tensorflow_internal.TFE_Py_TapeSetRestartOnThread

def TFE_Py_TapeSetRecordOperation(op_type, output_tensors, input_tensor_ids, backward_function):
    return _pywrap_tensorflow_internal.TFE_Py_TapeSetRecordOperation(op_type, output_tensors, input_tensor_ids, backward_function)
TFE_Py_TapeSetRecordOperation = _pywrap_tensorflow_internal.TFE_Py_TapeSetRecordOperation

def TFE_Py_TapeVariableAccessed(variable):
    return _pywrap_tensorflow_internal.TFE_Py_TapeVariableAccessed(variable)
TFE_Py_TapeVariableAccessed = _pywrap_tensorflow_internal.TFE_Py_TapeVariableAccessed

def TFE_Py_TapeWatchVariable(tape, variable):
    return _pywrap_tensorflow_internal.TFE_Py_TapeWatchVariable(tape, variable)
TFE_Py_TapeWatchVariable = _pywrap_tensorflow_internal.TFE_Py_TapeWatchVariable

def TFE_Py_TapeGradient(tape, target, sources, output_gradients, sources_raw, unconnected_gradients):
    return _pywrap_tensorflow_internal.TFE_Py_TapeGradient(tape, target, sources, output_gradients, sources_raw, unconnected_gradients)
TFE_Py_TapeGradient = _pywrap_tensorflow_internal.TFE_Py_TapeGradient

def TFE_Py_RecordGradient(op_name, inputs, attrs, results, name):
    return _pywrap_tensorflow_internal.TFE_Py_RecordGradient(op_name, inputs, attrs, results, name)
TFE_Py_RecordGradient = _pywrap_tensorflow_internal.TFE_Py_RecordGradient

def TFE_Py_TapeWatchedVariables(tape):
    return _pywrap_tensorflow_internal.TFE_Py_TapeWatchedVariables(tape)
TFE_Py_TapeWatchedVariables = _pywrap_tensorflow_internal.TFE_Py_TapeWatchedVariables

def TFE_Py_TensorShapeSlice(tensors, slice_dim):
    return _pywrap_tensorflow_internal.TFE_Py_TensorShapeSlice(tensors, slice_dim)
TFE_Py_TensorShapeSlice = _pywrap_tensorflow_internal.TFE_Py_TensorShapeSlice

def TFE_Py_TensorShapeOnDevice(tensor):
    return _pywrap_tensorflow_internal.TFE_Py_TensorShapeOnDevice(tensor)
TFE_Py_TensorShapeOnDevice = _pywrap_tensorflow_internal.TFE_Py_TensorShapeOnDevice

def TFE_Py_EncodeArg(arg1, include_tensor_ranks_only):
    return _pywrap_tensorflow_internal.TFE_Py_EncodeArg(arg1, include_tensor_ranks_only)
TFE_Py_EncodeArg = _pywrap_tensorflow_internal.TFE_Py_EncodeArg

def TFE_Py_EnableInteractivePythonLogging():
    return _pywrap_tensorflow_internal.TFE_Py_EnableInteractivePythonLogging()
TFE_Py_EnableInteractivePythonLogging = _pywrap_tensorflow_internal.TFE_Py_EnableInteractivePythonLogging

def TF_SetXlaEnableLazyCompilation(enable):
    return _pywrap_tensorflow_internal.TF_SetXlaEnableLazyCompilation(enable)
TF_SetXlaEnableLazyCompilation = _pywrap_tensorflow_internal.TF_SetXlaEnableLazyCompilation

def TF_SetXLaAutoJitMode(mode):
    return _pywrap_tensorflow_internal.TF_SetXLaAutoJitMode(mode)
TF_SetXLaAutoJitMode = _pywrap_tensorflow_internal.TF_SetXLaAutoJitMode

def TF_SetXlaMinClusterSize(size):
    return _pywrap_tensorflow_internal.TF_SetXlaMinClusterSize(size)
TF_SetXlaMinClusterSize = _pywrap_tensorflow_internal.TF_SetXlaMinClusterSize

def TF_PickUnusedPortOrDie():
    return _pywrap_tensorflow_internal.TF_PickUnusedPortOrDie()
TF_PickUnusedPortOrDie = _pywrap_tensorflow_internal.TF_PickUnusedPortOrDie

def TFE_EnableCollectiveOps(ctx, proto):
    return _pywrap_tensorflow_internal.TFE_EnableCollectiveOps(ctx, proto)
TFE_EnableCollectiveOps = _pywrap_tensorflow_internal.TFE_EnableCollectiveOps

def TFE_NewProfiler(ctx):
    return _pywrap_tensorflow_internal.TFE_NewProfiler(ctx)
TFE_NewProfiler = _pywrap_tensorflow_internal.TFE_NewProfiler

def TFE_ProfilerIsOk(profiler):
    return _pywrap_tensorflow_internal.TFE_ProfilerIsOk(profiler)
TFE_ProfilerIsOk = _pywrap_tensorflow_internal.TFE_ProfilerIsOk

def TFE_DeleteProfiler(profiler):
    return _pywrap_tensorflow_internal.TFE_DeleteProfiler(profiler)
TFE_DeleteProfiler = _pywrap_tensorflow_internal.TFE_DeleteProfiler

def TFE_ProfilerSerializeToString(ctx, profiler, buf):
    return _pywrap_tensorflow_internal.TFE_ProfilerSerializeToString(ctx, profiler, buf)
TFE_ProfilerSerializeToString = _pywrap_tensorflow_internal.TFE_ProfilerSerializeToString

def TFE_NewProfilerContext():
    return _pywrap_tensorflow_internal.TFE_NewProfilerContext()
TFE_NewProfilerContext = _pywrap_tensorflow_internal.TFE_NewProfilerContext

def TFE_ProfilerContextSetEagerContext(profiler_context, eager_context):
    return _pywrap_tensorflow_internal.TFE_ProfilerContextSetEagerContext(profiler_context, eager_context)
TFE_ProfilerContextSetEagerContext = _pywrap_tensorflow_internal.TFE_ProfilerContextSetEagerContext

def TFE_DeleteProfilerContext(profiler_context):
    return _pywrap_tensorflow_internal.TFE_DeleteProfilerContext(profiler_context)
TFE_DeleteProfilerContext = _pywrap_tensorflow_internal.TFE_DeleteProfilerContext

def TFE_StartProfilerServer(context, port):
    return _pywrap_tensorflow_internal.TFE_StartProfilerServer(context, port)
TFE_StartProfilerServer = _pywrap_tensorflow_internal.TFE_StartProfilerServer

def TFE_ContextEnableGraphCollection(ctx):
    return _pywrap_tensorflow_internal.TFE_ContextEnableGraphCollection(ctx)
TFE_ContextEnableGraphCollection = _pywrap_tensorflow_internal.TFE_ContextEnableGraphCollection

def TFE_ContextDisableGraphCollection(ctx):
    return _pywrap_tensorflow_internal.TFE_ContextDisableGraphCollection(ctx)
TFE_ContextDisableGraphCollection = _pywrap_tensorflow_internal.TFE_ContextDisableGraphCollection

def TFE_ProfilerClientStartTracing(service_addr, logdir, worker_list, include_dataset_ops, duration_ms, num_tracing_attempts):
    return _pywrap_tensorflow_internal.TFE_ProfilerClientStartTracing(service_addr, logdir, worker_list, include_dataset_ops, duration_ms, num_tracing_attempts)
TFE_ProfilerClientStartTracing = _pywrap_tensorflow_internal.TFE_ProfilerClientStartTracing

def TFE_MonitoringCounterCellIncrementBy(cell, value):
    return _pywrap_tensorflow_internal.TFE_MonitoringCounterCellIncrementBy(cell, value)
TFE_MonitoringCounterCellIncrementBy = _pywrap_tensorflow_internal.TFE_MonitoringCounterCellIncrementBy

def TFE_MonitoringCounterCellValue(cell):
    return _pywrap_tensorflow_internal.TFE_MonitoringCounterCellValue(cell)
TFE_MonitoringCounterCellValue = _pywrap_tensorflow_internal.TFE_MonitoringCounterCellValue

def TFE_MonitoringNewCounter0(name, description):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewCounter0(name, description)
TFE_MonitoringNewCounter0 = _pywrap_tensorflow_internal.TFE_MonitoringNewCounter0

def TFE_MonitoringDeleteCounter0(counter):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteCounter0(counter)
TFE_MonitoringDeleteCounter0 = _pywrap_tensorflow_internal.TFE_MonitoringDeleteCounter0

def TFE_MonitoringGetCellCounter0(counter):
    return _pywrap_tensorflow_internal.TFE_MonitoringGetCellCounter0(counter)
TFE_MonitoringGetCellCounter0 = _pywrap_tensorflow_internal.TFE_MonitoringGetCellCounter0

def TFE_MonitoringNewCounter1(name, description, label1):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewCounter1(name, description, label1)
TFE_MonitoringNewCounter1 = _pywrap_tensorflow_internal.TFE_MonitoringNewCounter1

def TFE_MonitoringDeleteCounter1(counter):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteCounter1(counter)
TFE_MonitoringDeleteCounter1 = _pywrap_tensorflow_internal.TFE_MonitoringDeleteCounter1

def TFE_MonitoringGetCellCounter1(counter, label1):
    return _pywrap_tensorflow_internal.TFE_MonitoringGetCellCounter1(counter, label1)
TFE_MonitoringGetCellCounter1 = _pywrap_tensorflow_internal.TFE_MonitoringGetCellCounter1

def TFE_MonitoringNewCounter2(name, description, label1, label2):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewCounter2(name, description, label1, label2)
TFE_MonitoringNewCounter2 = _pywrap_tensorflow_internal.TFE_MonitoringNewCounter2

def TFE_MonitoringDeleteCounter2(counter):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteCounter2(counter)
TFE_MonitoringDeleteCounter2 = _pywrap_tensorflow_internal.TFE_MonitoringDeleteCounter2

def TFE_MonitoringGetCellCounter2(counter, label1, label2):
    return _pywrap_tensorflow_internal.TFE_MonitoringGetCellCounter2(counter, label1, label2)
TFE_MonitoringGetCellCounter2 = _pywrap_tensorflow_internal.TFE_MonitoringGetCellCounter2

def TFE_MonitoringIntGaugeCellSet(cell, value):
    return _pywrap_tensorflow_internal.TFE_MonitoringIntGaugeCellSet(cell, value)
TFE_MonitoringIntGaugeCellSet = _pywrap_tensorflow_internal.TFE_MonitoringIntGaugeCellSet

def TFE_MonitoringIntGaugeCellValue(cell):
    return _pywrap_tensorflow_internal.TFE_MonitoringIntGaugeCellValue(cell)
TFE_MonitoringIntGaugeCellValue = _pywrap_tensorflow_internal.TFE_MonitoringIntGaugeCellValue

def TFE_MonitoringNewIntGauge0(name, description):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewIntGauge0(name, description)
TFE_MonitoringNewIntGauge0 = _pywrap_tensorflow_internal.TFE_MonitoringNewIntGauge0

def TFE_MonitoringDeleteIntGauge0(gauge):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteIntGauge0(gauge)
TFE_MonitoringDeleteIntGauge0 = _pywrap_tensorflow_internal.TFE_MonitoringDeleteIntGauge0

def TFE_MonitoringGetCellIntGauge0(gauge):
    return _pywrap_tensorflow_internal.TFE_MonitoringGetCellIntGauge0(gauge)
TFE_MonitoringGetCellIntGauge0 = _pywrap_tensorflow_internal.TFE_MonitoringGetCellIntGauge0

def TFE_MonitoringNewIntGauge1(name, description, label1):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewIntGauge1(name, description, label1)
TFE_MonitoringNewIntGauge1 = _pywrap_tensorflow_internal.TFE_MonitoringNewIntGauge1

def TFE_MonitoringDeleteIntGauge1(gauge):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteIntGauge1(gauge)
TFE_MonitoringDeleteIntGauge1 = _pywrap_tensorflow_internal.TFE_MonitoringDeleteIntGauge1

def TFE_MonitoringGetCellIntGauge1(gauge, label1):
    return _pywrap_tensorflow_internal.TFE_MonitoringGetCellIntGauge1(gauge, label1)
TFE_MonitoringGetCellIntGauge1 = _pywrap_tensorflow_internal.TFE_MonitoringGetCellIntGauge1

def TFE_MonitoringNewIntGauge2(name, description, label1, label2):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewIntGauge2(name, description, label1, label2)
TFE_MonitoringNewIntGauge2 = _pywrap_tensorflow_internal.TFE_MonitoringNewIntGauge2

def TFE_MonitoringDeleteIntGauge2(gauge):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteIntGauge2(gauge)
TFE_MonitoringDeleteIntGauge2 = _pywrap_tensorflow_internal.TFE_MonitoringDeleteIntGauge2

def TFE_MonitoringGetCellIntGauge2(gauge, label1, label2):
    return _pywrap_tensorflow_internal.TFE_MonitoringGetCellIntGauge2(gauge, label1, label2)
TFE_MonitoringGetCellIntGauge2 = _pywrap_tensorflow_internal.TFE_MonitoringGetCellIntGauge2

def TFE_MonitoringStringGaugeCellSet(cell, value):
    return _pywrap_tensorflow_internal.TFE_MonitoringStringGaugeCellSet(cell, value)
TFE_MonitoringStringGaugeCellSet = _pywrap_tensorflow_internal.TFE_MonitoringStringGaugeCellSet

def TFE_MonitoringStringGaugeCellValue(cell, buf):
    return _pywrap_tensorflow_internal.TFE_MonitoringStringGaugeCellValue(cell, buf)
TFE_MonitoringStringGaugeCellValue = _pywrap_tensorflow_internal.TFE_MonitoringStringGaugeCellValue

def TFE_MonitoringNewStringGauge0(name, description):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewStringGauge0(name, description)
TFE_MonitoringNewStringGauge0 = _pywrap_tensorflow_internal.TFE_MonitoringNewStringGauge0

def TFE_MonitoringDeleteStringGauge0(gauge):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteStringGauge0(gauge)
TFE_MonitoringDeleteStringGauge0 = _pywrap_tensorflow_internal.TFE_MonitoringDeleteStringGauge0

def TFE_MonitoringGetCellStringGauge0(gauge):
    return _pywrap_tensorflow_internal.TFE_MonitoringGetCellStringGauge0(gauge)
TFE_MonitoringGetCellStringGauge0 = _pywrap_tensorflow_internal.TFE_MonitoringGetCellStringGauge0

def TFE_MonitoringNewStringGauge1(name, description, label1):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewStringGauge1(name, description, label1)
TFE_MonitoringNewStringGauge1 = _pywrap_tensorflow_internal.TFE_MonitoringNewStringGauge1

def TFE_MonitoringDeleteStringGauge1(gauge):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteStringGauge1(gauge)
TFE_MonitoringDeleteStringGauge1 = _pywrap_tensorflow_internal.TFE_MonitoringDeleteStringGauge1

def TFE_MonitoringGetCellStringGauge1(gauge, label1):
    return _pywrap_tensorflow_internal.TFE_MonitoringGetCellStringGauge1(gauge, label1)
TFE_MonitoringGetCellStringGauge1 = _pywrap_tensorflow_internal.TFE_MonitoringGetCellStringGauge1

def TFE_MonitoringNewStringGauge2(name, description, label1, label2):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewStringGauge2(name, description, label1, label2)
TFE_MonitoringNewStringGauge2 = _pywrap_tensorflow_internal.TFE_MonitoringNewStringGauge2

def TFE_MonitoringDeleteStringGauge2(gauge):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteStringGauge2(gauge)
TFE_MonitoringDeleteStringGauge2 = _pywrap_tensorflow_internal.TFE_MonitoringDeleteStringGauge2

def TFE_MonitoringGetCellStringGauge2(gauge, label1, label2):
    return _pywrap_tensorflow_internal.TFE_MonitoringGetCellStringGauge2(gauge, label1, label2)
TFE_MonitoringGetCellStringGauge2 = _pywrap_tensorflow_internal.TFE_MonitoringGetCellStringGauge2

def TFE_MonitoringBoolGaugeCellSet(cell, value):
    return _pywrap_tensorflow_internal.TFE_MonitoringBoolGaugeCellSet(cell, value)
TFE_MonitoringBoolGaugeCellSet = _pywrap_tensorflow_internal.TFE_MonitoringBoolGaugeCellSet

def TFE_MonitoringBoolGaugeCellValue(cell):
    return _pywrap_tensorflow_internal.TFE_MonitoringBoolGaugeCellValue(cell)
TFE_MonitoringBoolGaugeCellValue = _pywrap_tensorflow_internal.TFE_MonitoringBoolGaugeCellValue

def TFE_MonitoringNewBoolGauge0(name, description):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewBoolGauge0(name, description)
TFE_MonitoringNewBoolGauge0 = _pywrap_tensorflow_internal.TFE_MonitoringNewBoolGauge0

def TFE_MonitoringDeleteBoolGauge0(gauge):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteBoolGauge0(gauge)
TFE_MonitoringDeleteBoolGauge0 = _pywrap_tensorflow_internal.TFE_MonitoringDeleteBoolGauge0

def TFE_MonitoringGetCellBoolGauge0(gauge):
    return _pywrap_tensorflow_internal.TFE_MonitoringGetCellBoolGauge0(gauge)
TFE_MonitoringGetCellBoolGauge0 = _pywrap_tensorflow_internal.TFE_MonitoringGetCellBoolGauge0

def TFE_MonitoringNewBoolGauge1(name, description, label1):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewBoolGauge1(name, description, label1)
TFE_MonitoringNewBoolGauge1 = _pywrap_tensorflow_internal.TFE_MonitoringNewBoolGauge1

def TFE_MonitoringDeleteBoolGauge1(gauge):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteBoolGauge1(gauge)
TFE_MonitoringDeleteBoolGauge1 = _pywrap_tensorflow_internal.TFE_MonitoringDeleteBoolGauge1

def TFE_MonitoringGetCellBoolGauge1(gauge, label1):
    return _pywrap_tensorflow_internal.TFE_MonitoringGetCellBoolGauge1(gauge, label1)
TFE_MonitoringGetCellBoolGauge1 = _pywrap_tensorflow_internal.TFE_MonitoringGetCellBoolGauge1

def TFE_MonitoringNewBoolGauge2(name, description, label1, label2):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewBoolGauge2(name, description, label1, label2)
TFE_MonitoringNewBoolGauge2 = _pywrap_tensorflow_internal.TFE_MonitoringNewBoolGauge2

def TFE_MonitoringDeleteBoolGauge2(gauge):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteBoolGauge2(gauge)
TFE_MonitoringDeleteBoolGauge2 = _pywrap_tensorflow_internal.TFE_MonitoringDeleteBoolGauge2

def TFE_MonitoringGetCellBoolGauge2(gauge, label1, label2):
    return _pywrap_tensorflow_internal.TFE_MonitoringGetCellBoolGauge2(gauge, label1, label2)
TFE_MonitoringGetCellBoolGauge2 = _pywrap_tensorflow_internal.TFE_MonitoringGetCellBoolGauge2

def TFE_MonitoringSamplerCellAdd(cell, value):
    return _pywrap_tensorflow_internal.TFE_MonitoringSamplerCellAdd(cell, value)
TFE_MonitoringSamplerCellAdd = _pywrap_tensorflow_internal.TFE_MonitoringSamplerCellAdd

def TFE_MonitoringSamplerCellValue(cell, buf):
    return _pywrap_tensorflow_internal.TFE_MonitoringSamplerCellValue(cell, buf)
TFE_MonitoringSamplerCellValue = _pywrap_tensorflow_internal.TFE_MonitoringSamplerCellValue

def TFE_MonitoringNewExponentialBuckets(scale, growth_factor, bucket_count):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewExponentialBuckets(scale, growth_factor, bucket_count)
TFE_MonitoringNewExponentialBuckets = _pywrap_tensorflow_internal.TFE_MonitoringNewExponentialBuckets

def TFE_MonitoringDeleteBuckets(buckets):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteBuckets(buckets)
TFE_MonitoringDeleteBuckets = _pywrap_tensorflow_internal.TFE_MonitoringDeleteBuckets

def TFE_MonitoringNewSampler0(name, buckets, description):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewSampler0(name, buckets, description)
TFE_MonitoringNewSampler0 = _pywrap_tensorflow_internal.TFE_MonitoringNewSampler0

def TFE_MonitoringDeleteSampler0(sampler):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteSampler0(sampler)
TFE_MonitoringDeleteSampler0 = _pywrap_tensorflow_internal.TFE_MonitoringDeleteSampler0

def TFE_MonitoringGetCellSampler0(sampler):
    return _pywrap_tensorflow_internal.TFE_MonitoringGetCellSampler0(sampler)
TFE_MonitoringGetCellSampler0 = _pywrap_tensorflow_internal.TFE_MonitoringGetCellSampler0

def TFE_MonitoringNewSampler1(name, buckets, description, label1):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewSampler1(name, buckets, description, label1)
TFE_MonitoringNewSampler1 = _pywrap_tensorflow_internal.TFE_MonitoringNewSampler1

def TFE_MonitoringDeleteSampler1(sampler):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteSampler1(sampler)
TFE_MonitoringDeleteSampler1 = _pywrap_tensorflow_internal.TFE_MonitoringDeleteSampler1

def TFE_MonitoringGetCellSampler1(sampler, label1):
    return _pywrap_tensorflow_internal.TFE_MonitoringGetCellSampler1(sampler, label1)
TFE_MonitoringGetCellSampler1 = _pywrap_tensorflow_internal.TFE_MonitoringGetCellSampler1

def TFE_MonitoringNewSampler2(name, buckets, description, label1, label2):
    return _pywrap_tensorflow_internal.TFE_MonitoringNewSampler2(name, buckets, description, label1, label2)
TFE_MonitoringNewSampler2 = _pywrap_tensorflow_internal.TFE_MonitoringNewSampler2

def TFE_MonitoringDeleteSampler2(sampler):
    return _pywrap_tensorflow_internal.TFE_MonitoringDeleteSampler2(sampler)
TFE_MonitoringDeleteSampler2 = _pywrap_tensorflow_internal.TFE_MonitoringDeleteSampler2

def TFE_MonitoringGetCellSampler2(sampler, label1, label2):
    return _pywrap_tensorflow_internal.TFE_MonitoringGetCellSampler2(sampler, label1, label2)
TFE_MonitoringGetCellSampler2 = _pywrap_tensorflow_internal.TFE_MonitoringGetCellSampler2

def IsGoogleCudaEnabled():
    return _pywrap_tensorflow_internal.IsGoogleCudaEnabled()
IsGoogleCudaEnabled = _pywrap_tensorflow_internal.IsGoogleCudaEnabled

def IsBuiltWithROCm():
    return _pywrap_tensorflow_internal.IsBuiltWithROCm()
IsBuiltWithROCm = _pywrap_tensorflow_internal.IsBuiltWithROCm

def GpuSupportsHalfMatMulAndConv():
    return _pywrap_tensorflow_internal.GpuSupportsHalfMatMulAndConv()
GpuSupportsHalfMatMulAndConv = _pywrap_tensorflow_internal.GpuSupportsHalfMatMulAndConv

def IsMklEnabled():
    return _pywrap_tensorflow_internal.IsMklEnabled()
IsMklEnabled = _pywrap_tensorflow_internal.IsMklEnabled

def CheckpointReader_GetTensor(reader, name):
    return _pywrap_tensorflow_internal.CheckpointReader_GetTensor(reader, name)
CheckpointReader_GetTensor = _pywrap_tensorflow_internal.CheckpointReader_GetTensor

def NewCheckpointReader(filepattern):
  from tensorflow.python.util import compat
  return CheckpointReader(compat.as_bytes(filepattern))

NewCheckpointReader._tf_api_names_v1 = ['train.NewCheckpointReader']

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, filename):
        this = _pywrap_tensorflow_internal.new_CheckpointReader(filename)
        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.util import compat

      return CheckpointReader_GetTensor(self, compat.as_bytes(tensor_str))

    __swig_destroy__ = _pywrap_tensorflow_internal.delete_CheckpointReader
    __del__ = lambda self: None
CheckpointReader_swigregister = _pywrap_tensorflow_internal.CheckpointReader_swigregister
CheckpointReader_swigregister(CheckpointReader)
TFE_Py_FastPathExecute = _pywrap_tensorflow_internal.TFE_Py_FastPathExecute


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 SerializeToString():
    return _pywrap_tensorflow_internal.SerializeToString()
SerializeToString = _pywrap_tensorflow_internal.SerializeToString

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 PyExceptionRegistry(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PyExceptionRegistry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PyExceptionRegistry, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["Init"] = lambda x: _pywrap_tensorflow_internal.PyExceptionRegistry_Init
    if _newclass:
        Init = staticmethod(_pywrap_tensorflow_internal.PyExceptionRegistry_Init)
    __swig_destroy__ = _pywrap_tensorflow_internal.delete_PyExceptionRegistry
    __del__ = lambda self: None
PyExceptionRegistry_swigregister = _pywrap_tensorflow_internal.PyExceptionRegistry_swigregister
PyExceptionRegistry_swigregister(PyExceptionRegistry)

def PyExceptionRegistry_Init(code_to_exc_type_map):
    return _pywrap_tensorflow_internal.PyExceptionRegistry_Init(code_to_exc_type_map)
PyExceptionRegistry_Init = _pywrap_tensorflow_internal.PyExceptionRegistry_Init

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):
        return _pywrap_tensorflow_internal.PyRecordReader_GetNext(self)

    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 RecordWriterOptions(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RecordWriterOptions, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RecordWriterOptions, name)
    __repr__ = _swig_repr
    __swig_getmethods__["CreateRecordWriterOptions"] = lambda x: _pywrap_tensorflow_internal.RecordWriterOptions_CreateRecordWriterOptions
    if _newclass:
        CreateRecordWriterOptions = staticmethod(_pywrap_tensorflow_internal.RecordWriterOptions_CreateRecordWriterOptions)
    __swig_setmethods__["zlib_options"] = _pywrap_tensorflow_internal.RecordWriterOptions_zlib_options_set
    __swig_getmethods__["zlib_options"] = _pywrap_tensorflow_internal.RecordWriterOptions_zlib_options_get
    if _newclass:
        zlib_options = _swig_property(_pywrap_tensorflow_internal.RecordWriterOptions_zlib_options_get, _pywrap_tensorflow_internal.RecordWriterOptions_zlib_options_set)

    def __init__(self):
        this = _pywrap_tensorflow_internal.new_RecordWriterOptions()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _pywrap_tensorflow_internal.delete_RecordWriterOptions
    __del__ = lambda self: None
RecordWriterOptions_swigregister = _pywrap_tensorflow_internal.RecordWriterOptions_swigregister
RecordWriterOptions_swigregister(RecordWriterOptions)

def RecordWriterOptions_CreateRecordWriterOptions(compression_type):
    return _pywrap_tensorflow_internal.RecordWriterOptions_CreateRecordWriterOptions(compression_type)
RecordWriterOptions_CreateRecordWriterOptions = _pywrap_tensorflow_internal.RecordWriterOptions_CreateRecordWriterOptions

class ZlibCompressionOptions(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ZlibCompressionOptions, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ZlibCompressionOptions, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["flush_mode"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_flush_mode_set
    __swig_getmethods__["flush_mode"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_flush_mode_get
    if _newclass:
        flush_mode = _swig_property(_pywrap_tensorflow_internal.ZlibCompressionOptions_flush_mode_get, _pywrap_tensorflow_internal.ZlibCompressionOptions_flush_mode_set)
    __swig_setmethods__["input_buffer_size"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_input_buffer_size_set
    __swig_getmethods__["input_buffer_size"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_input_buffer_size_get
    if _newclass:
        input_buffer_size = _swig_property(_pywrap_tensorflow_internal.ZlibCompressionOptions_input_buffer_size_get, _pywrap_tensorflow_internal.ZlibCompressionOptions_input_buffer_size_set)
    __swig_setmethods__["output_buffer_size"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_output_buffer_size_set
    __swig_getmethods__["output_buffer_size"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_output_buffer_size_get
    if _newclass:
        output_buffer_size = _swig_property(_pywrap_tensorflow_internal.ZlibCompressionOptions_output_buffer_size_get, _pywrap_tensorflow_internal.ZlibCompressionOptions_output_buffer_size_set)
    __swig_setmethods__["window_bits"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_window_bits_set
    __swig_getmethods__["window_bits"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_window_bits_get
    if _newclass:
        window_bits = _swig_property(_pywrap_tensorflow_internal.ZlibCompressionOptions_window_bits_get, _pywrap_tensorflow_internal.ZlibCompressionOptions_window_bits_set)
    __swig_setmethods__["compression_level"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_compression_level_set
    __swig_getmethods__["compression_level"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_compression_level_get
    if _newclass:
        compression_level = _swig_property(_pywrap_tensorflow_internal.ZlibCompressionOptions_compression_level_get, _pywrap_tensorflow_internal.ZlibCompressionOptions_compression_level_set)
    __swig_setmethods__["compression_method"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_compression_method_set
    __swig_getmethods__["compression_method"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_compression_method_get
    if _newclass:
        compression_method = _swig_property(_pywrap_tensorflow_internal.ZlibCompressionOptions_compression_method_get, _pywrap_tensorflow_internal.ZlibCompressionOptions_compression_method_set)
    __swig_setmethods__["mem_level"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_mem_level_set
    __swig_getmethods__["mem_level"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_mem_level_get
    if _newclass:
        mem_level = _swig_property(_pywrap_tensorflow_internal.ZlibCompressionOptions_mem_level_get, _pywrap_tensorflow_internal.ZlibCompressionOptions_mem_level_set)
    __swig_setmethods__["compression_strategy"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_compression_strategy_set
    __swig_getmethods__["compression_strategy"] = _pywrap_tensorflow_internal.ZlibCompressionOptions_compression_strategy_get
    if _newclass:
        compression_strategy = _swig_property(_pywrap_tensorflow_internal.ZlibCompressionOptions_compression_strategy_get, _pywrap_tensorflow_internal.ZlibCompressionOptions_compression_strategy_set)
    __swig_destroy__ = _pywrap_tensorflow_internal.delete_ZlibCompressionOptions
    __del__ = lambda self: None
ZlibCompressionOptions_swigregister = _pywrap_tensorflow_internal.ZlibCompressionOptions_swigregister
ZlibCompressionOptions_swigregister(ZlibCompressionOptions)

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, out_status):
        return _pywrap_tensorflow_internal.PyRecordWriter_WriteRecord(self, record, out_status)

    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_options, out_status):
    return _pywrap_tensorflow_internal.PyRecordWriter_New(filename, compression_options, out_status)
PyRecordWriter_New = _pywrap_tensorflow_internal.PyRecordWriter_New

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

class StatusGroup(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StatusGroup, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StatusGroup, name)
    __repr__ = _swig_repr
    __swig_getmethods__["MakeDerived"] = lambda x: _pywrap_tensorflow_internal.StatusGroup_MakeDerived
    if _newclass:
        MakeDerived = staticmethod(_pywrap_tensorflow_internal.StatusGroup_MakeDerived)
    __swig_getmethods__["IsDerived"] = lambda x: _pywrap_tensorflow_internal.StatusGroup_IsDerived
    if _newclass:
        IsDerived = staticmethod(_pywrap_tensorflow_internal.StatusGroup_IsDerived)

    def as_summary_status(self):
        return _pywrap_tensorflow_internal.StatusGroup_as_summary_status(self)

    def as_concatenated_status(self):
        return _pywrap_tensorflow_internal.StatusGroup_as_concatenated_status(self)

    def ok(self):
        return _pywrap_tensorflow_internal.StatusGroup_ok(self)

    def Update(self, status):
        return _pywrap_tensorflow_internal.StatusGroup_Update(self, status)

    def __init__(self):
        this = _pywrap_tensorflow_internal.new_StatusGroup()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _pywrap_tensorflow_internal.delete_StatusGroup
    __del__ = lambda self: None
StatusGroup_swigregister = _pywrap_tensorflow_internal.StatusGroup_swigregister
StatusGroup_swigregister(StatusGroup)

def StatusGroup_MakeDerived(s):
    return _pywrap_tensorflow_internal.StatusGroup_MakeDerived(s)
StatusGroup_MakeDerived = _pywrap_tensorflow_internal.StatusGroup_MakeDerived

def StatusGroup_IsDerived(s):
    return _pywrap_tensorflow_internal.StatusGroup_IsDerived(s)
StatusGroup_IsDerived = _pywrap_tensorflow_internal.StatusGroup_IsDerived


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 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.__cxx11_abi_flag___swigconstant(_pywrap_tensorflow_internal)
__cxx11_abi_flag__ = _pywrap_tensorflow_internal.__cxx11_abi_flag__

_pywrap_tensorflow_internal.__monolithic_build___swigconstant(_pywrap_tensorflow_internal)
__monolithic_build__ = _pywrap_tensorflow_internal.__monolithic_build__

_pywrap_tensorflow_internal.TENSOR_HANDLE_KEY_swigconstant(_pywrap_tensorflow_internal)
TENSOR_HANDLE_KEY = _pywrap_tensorflow_internal.TENSOR_HANDLE_KEY

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

_pywrap_tensorflow_internal.TF_UINT32_swigconstant(_pywrap_tensorflow_internal)
TF_UINT32 = _pywrap_tensorflow_internal.TF_UINT32

_pywrap_tensorflow_internal.TF_UINT64_swigconstant(_pywrap_tensorflow_internal)
TF_UINT64 = _pywrap_tensorflow_internal.TF_UINT64

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_TensorElementCount(tensor):
    return _pywrap_tensorflow_internal.TF_TensorElementCount(tensor)
TF_TensorElementCount = _pywrap_tensorflow_internal.TF_TensorElementCount

def TF_TensorBitcastFrom(arg1, type, to, new_dims, num_new_dims):
    return _pywrap_tensorflow_internal.TF_TensorBitcastFrom(arg1, type, to, new_dims, num_new_dims)
TF_TensorBitcastFrom = _pywrap_tensorflow_internal.TF_TensorBitcastFrom

def TF_StringEncode(src, src_len, dst, dst_len):
    return _pywrap_tensorflow_internal.TF_StringEncode(src, src_len, dst, dst_len)
TF_StringEncode = _pywrap_tensorflow_internal.TF_StringEncode

def TF_StringDecode(src, src_len, dst, dst_len):
    return _pywrap_tensorflow_internal.TF_StringDecode(src, src_len, dst, dst_len)
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):
    return _pywrap_tensorflow_internal._TF_SetConfig(options, proto)
_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):
    return _pywrap_tensorflow_internal.TF_GraphSetTensorShape(graph, output, dims, num_dims)
TF_GraphSetTensorShape = _pywrap_tensorflow_internal.TF_GraphSetTensorShape

def TF_GraphGetTensorNumDims(graph, output):
    return _pywrap_tensorflow_internal.TF_GraphGetTensorNumDims(graph, output)
TF_GraphGetTensorNumDims = _pywrap_tensorflow_internal.TF_GraphGetTensorNumDims

def TF_GraphGetTensorShape(graph, output, dims, num_dims):
    return _pywrap_tensorflow_internal.TF_GraphGetTensorShape(graph, output, dims, num_dims)
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_SetAttrPlaceholder(desc, attr_name, placeholder):
    return _pywrap_tensorflow_internal.TF_SetAttrPlaceholder(desc, attr_name, placeholder)
TF_SetAttrPlaceholder = _pywrap_tensorflow_internal.TF_SetAttrPlaceholder

def TF_SetAttrFuncName(desc, attr_name, value, length):
    return _pywrap_tensorflow_internal.TF_SetAttrFuncName(desc, attr_name, value, length)
TF_SetAttrFuncName = _pywrap_tensorflow_internal.TF_SetAttrFuncName

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):
    return _pywrap_tensorflow_internal.TF_SetAttrTensorShapeProto(desc, attr_name, proto)
TF_SetAttrTensorShapeProto = _pywrap_tensorflow_internal.TF_SetAttrTensorShapeProto

def TF_SetAttrTensorShapeProtoList(desc, attr_name, protos, proto_lens, num_shapes):
    return _pywrap_tensorflow_internal.TF_SetAttrTensorShapeProtoList(desc, attr_name, protos, proto_lens, num_shapes)
TF_SetAttrTensorShapeProtoList = _pywrap_tensorflow_internal.TF_SetAttrTensorShapeProtoList

def TF_SetAttrTensor(desc, attr_name, value):
    return _pywrap_tensorflow_internal.TF_SetAttrTensor(desc, attr_name, value)
TF_SetAttrTensor = _pywrap_tensorflow_internal.TF_SetAttrTensor

def TF_SetAttrTensorList(desc, attr_name, values, num_values):
    return _pywrap_tensorflow_internal.TF_SetAttrTensorList(desc, attr_name, values, num_values)
TF_SetAttrTensorList = _pywrap_tensorflow_internal.TF_SetAttrTensorList

def TF_SetAttrValueProto(desc, attr_name, proto):
    return _pywrap_tensorflow_internal.TF_SetAttrValueProto(desc, attr_name, proto)
TF_SetAttrValueProto = _pywrap_tensorflow_internal.TF_SetAttrValueProto

def TF_FinishOperation(desc):
    return _pywrap_tensorflow_internal.TF_FinishOperation(desc)
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):
    return _pywrap_tensorflow_internal.TF_OperationOutputListLength(oper, arg_name)
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):
    return _pywrap_tensorflow_internal.TF_OperationInputListLength(oper, arg_name)
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_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
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):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrMetadata(oper, attr_name)
TF_OperationGetAttrMetadata = _pywrap_tensorflow_internal.TF_OperationGetAttrMetadata

def TF_OperationGetAttrString(oper, attr_name, value, max_length):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrString(oper, attr_name, value, max_length)
TF_OperationGetAttrString = _pywrap_tensorflow_internal.TF_OperationGetAttrString

def TF_OperationGetAttrStringList(oper, attr_name, values, lengths, max_values, storage, storage_size):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrStringList(oper, attr_name, values, lengths, max_values, storage, storage_size)
TF_OperationGetAttrStringList = _pywrap_tensorflow_internal.TF_OperationGetAttrStringList

def TF_OperationGetAttrInt(oper, attr_name, value):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrInt(oper, attr_name, value)
TF_OperationGetAttrInt = _pywrap_tensorflow_internal.TF_OperationGetAttrInt

def TF_OperationGetAttrIntList(oper, attr_name, values, max_values):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrIntList(oper, attr_name, values, max_values)
TF_OperationGetAttrIntList = _pywrap_tensorflow_internal.TF_OperationGetAttrIntList

def TF_OperationGetAttrFloat(oper, attr_name, value):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrFloat(oper, attr_name, value)
TF_OperationGetAttrFloat = _pywrap_tensorflow_internal.TF_OperationGetAttrFloat

def TF_OperationGetAttrFloatList(oper, attr_name, values, max_values):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrFloatList(oper, attr_name, values, max_values)
TF_OperationGetAttrFloatList = _pywrap_tensorflow_internal.TF_OperationGetAttrFloatList

def TF_OperationGetAttrBool(oper, attr_name, value):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrBool(oper, attr_name, value)
TF_OperationGetAttrBool = _pywrap_tensorflow_internal.TF_OperationGetAttrBool

def TF_OperationGetAttrBoolList(oper, attr_name, values, max_values):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrBoolList(oper, attr_name, values, max_values)
TF_OperationGetAttrBoolList = _pywrap_tensorflow_internal.TF_OperationGetAttrBoolList

def TF_OperationGetAttrType(oper, attr_name, value):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrType(oper, attr_name, value)
TF_OperationGetAttrType = _pywrap_tensorflow_internal.TF_OperationGetAttrType

def TF_OperationGetAttrTypeList(oper, attr_name, values, max_values):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrTypeList(oper, attr_name, values, max_values)
TF_OperationGetAttrTypeList = _pywrap_tensorflow_internal.TF_OperationGetAttrTypeList

def TF_OperationGetAttrShape(oper, attr_name, value, num_dims):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrShape(oper, attr_name, value, num_dims)
TF_OperationGetAttrShape = _pywrap_tensorflow_internal.TF_OperationGetAttrShape

def TF_OperationGetAttrShapeList(oper, attr_name, dims, num_dims, num_shapes, storage, storage_size):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrShapeList(oper, attr_name, dims, num_dims, num_shapes, storage, storage_size)
TF_OperationGetAttrShapeList = _pywrap_tensorflow_internal.TF_OperationGetAttrShapeList

def TF_OperationGetAttrTensorShapeProto(oper, attr_name, value):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrTensorShapeProto(oper, attr_name, value)
TF_OperationGetAttrTensorShapeProto = _pywrap_tensorflow_internal.TF_OperationGetAttrTensorShapeProto

def TF_OperationGetAttrTensorShapeProtoList(oper, attr_name, values, max_values):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrTensorShapeProtoList(oper, attr_name, values, max_values)
TF_OperationGetAttrTensorShapeProtoList = _pywrap_tensorflow_internal.TF_OperationGetAttrTensorShapeProtoList

def TF_OperationGetAttrTensor(oper, attr_name, value):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrTensor(oper, attr_name, value)
TF_OperationGetAttrTensor = _pywrap_tensorflow_internal.TF_OperationGetAttrTensor

def TF_OperationGetAttrTensorList(oper, attr_name, values, max_values):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrTensorList(oper, attr_name, values, max_values)
TF_OperationGetAttrTensorList = _pywrap_tensorflow_internal.TF_OperationGetAttrTensorList

def TF_OperationGetAttrValueProto(oper, attr_name, output_attr_value):
    return _pywrap_tensorflow_internal.TF_OperationGetAttrValueProto(oper, attr_name, output_attr_value)
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):
    return _pywrap_tensorflow_internal.TF_GraphToGraphDef(graph, output_graph_def)
TF_GraphToGraphDef = _pywrap_tensorflow_internal.TF_GraphToGraphDef

def TF_GraphGetOpDef(graph, op_name, output_op_def):
    return _pywrap_tensorflow_internal.TF_GraphGetOpDef(graph, op_name, output_op_def)
TF_GraphGetOpDef = _pywrap_tensorflow_internal.TF_GraphGetOpDef

def TF_GraphVersions(graph, output_version_def):
    return _pywrap_tensorflow_internal.TF_GraphVersions(graph, output_version_def)
TF_GraphVersions = _pywrap_tensorflow_internal.TF_GraphVersions

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_ImportGraphDefOptionsSetDefaultDevice(opts, device):
    return _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsSetDefaultDevice(opts, device)
TF_ImportGraphDefOptionsSetDefaultDevice = _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsSetDefaultDevice

def TF_ImportGraphDefOptionsSetUniquifyNames(opts, uniquify_names):
    return _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsSetUniquifyNames(opts, uniquify_names)
TF_ImportGraphDefOptionsSetUniquifyNames = _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsSetUniquifyNames

def TF_ImportGraphDefOptionsSetUniquifyPrefix(opts, uniquify_prefix):
    return _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsSetUniquifyPrefix(opts, uniquify_prefix)
TF_ImportGraphDefOptionsSetUniquifyPrefix = _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsSetUniquifyPrefix

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_ImportGraphDefOptionsAddReturnOperation(opts, oper_name):
    return _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsAddReturnOperation(opts, oper_name)
TF_ImportGraphDefOptionsAddReturnOperation = _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsAddReturnOperation

def TF_ImportGraphDefOptionsNumReturnOperations(opts):
    return _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsNumReturnOperations(opts)
TF_ImportGraphDefOptionsNumReturnOperations = _pywrap_tensorflow_internal.TF_ImportGraphDefOptionsNumReturnOperations

def TF_ImportGraphDefResultsReturnOutputs(results):
    return _pywrap_tensorflow_internal.TF_ImportGraphDefResultsReturnOutputs(results)
TF_ImportGraphDefResultsReturnOutputs = _pywrap_tensorflow_internal.TF_ImportGraphDefResultsReturnOutputs

def TF_ImportGraphDefResultsReturnOperations(results):
    return _pywrap_tensorflow_internal.TF_ImportGraphDefResultsReturnOperations(results)
TF_ImportGraphDefResultsReturnOperations = _pywrap_tensorflow_internal.TF_ImportGraphDefResultsReturnOperations

def TF_DeleteImportGraphDefResults(results):
    return _pywrap_tensorflow_internal.TF_DeleteImportGraphDefResults(results)
TF_DeleteImportGraphDefResults = _pywrap_tensorflow_internal.TF_DeleteImportGraphDefResults

def TF_GraphImportGraphDefWithResults(graph, graph_def, options):
    return _pywrap_tensorflow_internal.TF_GraphImportGraphDefWithResults(graph, graph_def, options)
TF_GraphImportGraphDefWithResults = _pywrap_tensorflow_internal.TF_GraphImportGraphDefWithResults

def TF_GraphImportGraphDefWithReturnOutputs(graph, graph_def, options, return_outputs, num_return_outputs):
    return _pywrap_tensorflow_internal.TF_GraphImportGraphDefWithReturnOutputs(graph, graph_def, options, return_outputs, num_return_outputs)
TF_GraphImportGraphDefWithReturnOutputs = _pywrap_tensorflow_internal.TF_GraphImportGraphDefWithReturnOutputs

def TF_GraphImportGraphDef(graph, graph_def, options):
    return _pywrap_tensorflow_internal.TF_GraphImportGraphDef(graph, graph_def, options)
TF_GraphImportGraphDef = _pywrap_tensorflow_internal.TF_GraphImportGraphDef

def TF_GraphCopyFunction(g, func, grad):
    return _pywrap_tensorflow_internal.TF_GraphCopyFunction(g, func, grad)
TF_GraphCopyFunction = _pywrap_tensorflow_internal.TF_GraphCopyFunction

def TF_GraphNumFunctions(g):
    return _pywrap_tensorflow_internal.TF_GraphNumFunctions(g)
TF_GraphNumFunctions = _pywrap_tensorflow_internal.TF_GraphNumFunctions

def TF_GraphGetFunctions(g, funcs, max_func):
    return _pywrap_tensorflow_internal.TF_GraphGetFunctions(g, funcs, max_func)
TF_GraphGetFunctions = _pywrap_tensorflow_internal.TF_GraphGetFunctions

def TF_OperationToNodeDef(oper, output_node_def):
    return _pywrap_tensorflow_internal.TF_OperationToNodeDef(oper, output_node_def)
TF_OperationToNodeDef = _pywrap_tensorflow_internal.TF_OperationToNodeDef

def TF_AddGradients(g, y, ny, x, nx, dx, dy):
    return _pywrap_tensorflow_internal.TF_AddGradients(g, y, ny, x, nx, dx, dy)
TF_AddGradients = _pywrap_tensorflow_internal.TF_AddGradients

def TF_AddGradientsWithPrefix(g, prefix, y, ny, x, nx, dx, dy):
    return _pywrap_tensorflow_internal.TF_AddGradientsWithPrefix(g, prefix, y, ny, x, nx, dx, dy)
TF_AddGradientsWithPrefix = _pywrap_tensorflow_internal.TF_AddGradientsWithPrefix

def TF_GraphToFunction(fn_body, fn_name, append_hash_to_fn_name, num_opers, opers, ninputs, inputs, noutputs, outputs, output_names, opts, description):
    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)
TF_GraphToFunction = _pywrap_tensorflow_internal.TF_GraphToFunction

def TF_GraphToFunctionWithControlOutputs(fn_body, fn_name, append_hash_to_fn_name, num_opers, opers, ninputs, inputs, noutputs, outputs, output_names, ncontrol_outputs, control_outputs, control_output_names, opts, description):
    return _pywrap_tensorflow_internal.TF_GraphToFunctionWithControlOutputs(fn_body, fn_name, append_hash_to_fn_name, num_opers, opers, ninputs, inputs, noutputs, outputs, output_names, ncontrol_outputs, control_outputs, control_output_names, opts, description)
TF_GraphToFunctionWithControlOutputs = _pywrap_tensorflow_internal.TF_GraphToFunctionWithControlOutputs

def TF_FunctionName(func):
    return _pywrap_tensorflow_internal.TF_FunctionName(func)
TF_FunctionName = _pywrap_tensorflow_internal.TF_FunctionName

def TF_FunctionToFunctionDef(func, output_func_def):
    return _pywrap_tensorflow_internal.TF_FunctionToFunctionDef(func, output_func_def)
TF_FunctionToFunctionDef = _pywrap_tensorflow_internal.TF_FunctionToFunctionDef

def TF_FunctionImportFunctionDef(proto):
    return _pywrap_tensorflow_internal.TF_FunctionImportFunctionDef(proto)
TF_FunctionImportFunctionDef = _pywrap_tensorflow_internal.TF_FunctionImportFunctionDef

def TF_FunctionSetAttrValueProto(func, attr_name, proto):
    return _pywrap_tensorflow_internal.TF_FunctionSetAttrValueProto(func, attr_name, proto)
TF_FunctionSetAttrValueProto = _pywrap_tensorflow_internal.TF_FunctionSetAttrValueProto

def TF_FunctionGetAttrValueProto(func, attr_name, output_attr_value):
    return _pywrap_tensorflow_internal.TF_FunctionGetAttrValueProto(func, attr_name, output_attr_value)
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_TryEvaluateConstant(graph, output, result):
    return _pywrap_tensorflow_internal.TF_TryEvaluateConstant(graph, output, result)
TF_TryEvaluateConstant = _pywrap_tensorflow_internal.TF_TryEvaluateConstant

def TF_NewSession(graph, opts):
    return _pywrap_tensorflow_internal.TF_NewSession(graph, opts)
TF_NewSession = _pywrap_tensorflow_internal.TF_NewSession

def TF_LoadSessionFromSavedModel(session_options, run_options, export_dir, tags, tags_len, graph, meta_graph_def):
    return _pywrap_tensorflow_internal.TF_LoadSessionFromSavedModel(session_options, run_options, export_dir, tags, tags_len, graph, meta_graph_def)
TF_LoadSessionFromSavedModel = _pywrap_tensorflow_internal.TF_LoadSessionFromSavedModel

def TF_CloseSession(arg1):
    return _pywrap_tensorflow_internal.TF_CloseSession(arg1)
TF_CloseSession = _pywrap_tensorflow_internal.TF_CloseSession

def TF_DeleteSession(arg1):
    return _pywrap_tensorflow_internal.TF_DeleteSession(arg1)
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):
    return _pywrap_tensorflow_internal.TF_NewDeprecatedSession(arg1)
TF_NewDeprecatedSession = _pywrap_tensorflow_internal.TF_NewDeprecatedSession

def TF_CloseDeprecatedSession(arg1):
    return _pywrap_tensorflow_internal.TF_CloseDeprecatedSession(arg1)
TF_CloseDeprecatedSession = _pywrap_tensorflow_internal.TF_CloseDeprecatedSession

def TF_DeleteDeprecatedSession(arg1):
    return _pywrap_tensorflow_internal.TF_DeleteDeprecatedSession(arg1)
TF_DeleteDeprecatedSession = _pywrap_tensorflow_internal.TF_DeleteDeprecatedSession

def TF_Reset(opt, containers, ncontainers):
    return _pywrap_tensorflow_internal.TF_Reset(opt, containers, ncontainers)
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):
    return _pywrap_tensorflow_internal.TF_SessionListDevices(session)
TF_SessionListDevices = _pywrap_tensorflow_internal.TF_SessionListDevices

def TF_DeprecatedSessionListDevices(session):
    return _pywrap_tensorflow_internal.TF_DeprecatedSessionListDevices(session)
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):
    return _pywrap_tensorflow_internal.TF_DeviceListName(list, index)
TF_DeviceListName = _pywrap_tensorflow_internal.TF_DeviceListName

def TF_DeviceListType(list, index):
    return _pywrap_tensorflow_internal.TF_DeviceListType(list, index)
TF_DeviceListType = _pywrap_tensorflow_internal.TF_DeviceListType

def TF_DeviceListMemoryBytes(list, index):
    return _pywrap_tensorflow_internal.TF_DeviceListMemoryBytes(list, index)
TF_DeviceListMemoryBytes = _pywrap_tensorflow_internal.TF_DeviceListMemoryBytes

def TF_DeviceListIncarnation(list, index):
    return _pywrap_tensorflow_internal.TF_DeviceListIncarnation(list, index)
TF_DeviceListIncarnation = _pywrap_tensorflow_internal.TF_DeviceListIncarnation

def TF_LoadLibrary(library_filename):
    return _pywrap_tensorflow_internal.TF_LoadLibrary(library_filename)
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 TF_NewApiDefMap(op_list_buffer):
    return _pywrap_tensorflow_internal.TF_NewApiDefMap(op_list_buffer)
TF_NewApiDefMap = _pywrap_tensorflow_internal.TF_NewApiDefMap

def TF_DeleteApiDefMap(apimap):
    return _pywrap_tensorflow_internal.TF_DeleteApiDefMap(apimap)
TF_DeleteApiDefMap = _pywrap_tensorflow_internal.TF_DeleteApiDefMap

def TF_ApiDefMapPut(api_def_map, text, text_len):
    return _pywrap_tensorflow_internal.TF_ApiDefMapPut(api_def_map, text, text_len)
TF_ApiDefMapPut = _pywrap_tensorflow_internal.TF_ApiDefMapPut

def TF_ApiDefMapGet(api_def_map, name, name_len):
    return _pywrap_tensorflow_internal.TF_ApiDefMapGet(api_def_map, name, name_len)
TF_ApiDefMapGet = _pywrap_tensorflow_internal.TF_ApiDefMapGet

def TF_GetAllRegisteredKernels():
    return _pywrap_tensorflow_internal.TF_GetAllRegisteredKernels()
TF_GetAllRegisteredKernels = _pywrap_tensorflow_internal.TF_GetAllRegisteredKernels

def TF_GetRegisteredKernelsForOp(name):
    return _pywrap_tensorflow_internal.TF_GetRegisteredKernelsForOp(name)
TF_GetRegisteredKernelsForOp = _pywrap_tensorflow_internal.TF_GetRegisteredKernelsForOp

def TF_NewServer(proto):
    return _pywrap_tensorflow_internal.TF_NewServer(proto)
TF_NewServer = _pywrap_tensorflow_internal.TF_NewServer

def TF_ServerStart(server):
    return _pywrap_tensorflow_internal.TF_ServerStart(server)
TF_ServerStart = _pywrap_tensorflow_internal.TF_ServerStart

def TF_ServerStop(server):
    return _pywrap_tensorflow_internal.TF_ServerStop(server)
TF_ServerStop = _pywrap_tensorflow_internal.TF_ServerStop

def TF_ServerJoin(server):
    return _pywrap_tensorflow_internal.TF_ServerJoin(server)
TF_ServerJoin = _pywrap_tensorflow_internal.TF_ServerJoin

def TF_ServerTarget(server):
    return _pywrap_tensorflow_internal.TF_ServerTarget(server)
TF_ServerTarget = _pywrap_tensorflow_internal.TF_ServerTarget

def TF_DeleteServer(server):
    return _pywrap_tensorflow_internal.TF_DeleteServer(server)
TF_DeleteServer = _pywrap_tensorflow_internal.TF_DeleteServer

def TF_RegisterLogListener(listener):
    return _pywrap_tensorflow_internal.TF_RegisterLogListener(listener)
TF_RegisterLogListener = _pywrap_tensorflow_internal.TF_RegisterLogListener

_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

def AddControlInput(graph, op, input):
    return _pywrap_tensorflow_internal.AddControlInput(graph, op, input)
AddControlInput = _pywrap_tensorflow_internal.AddControlInput

def SetAttr(graph, op, attr_name, attr_value_proto):
    return _pywrap_tensorflow_internal.SetAttr(graph, op, attr_name, attr_value_proto)
SetAttr = _pywrap_tensorflow_internal.SetAttr

def ClearAttr(graph, op, attr_name):
    return _pywrap_tensorflow_internal.ClearAttr(graph, op, attr_name)
ClearAttr = _pywrap_tensorflow_internal.ClearAttr

def SetRequestedDevice(graph, op, device):
    return _pywrap_tensorflow_internal.SetRequestedDevice(graph, op, device)
SetRequestedDevice = _pywrap_tensorflow_internal.SetRequestedDevice

def UpdateEdge(graph, new_src, dst):
    return _pywrap_tensorflow_internal.UpdateEdge(graph, new_src, dst)
UpdateEdge = _pywrap_tensorflow_internal.UpdateEdge

def RemoveAllControlInputs(graph, op):
    return _pywrap_tensorflow_internal.RemoveAllControlInputs(graph, op)
RemoveAllControlInputs = _pywrap_tensorflow_internal.RemoveAllControlInputs

def SetRequireShapeInferenceFns(graph, require):
    return _pywrap_tensorflow_internal.SetRequireShapeInferenceFns(graph, require)
SetRequireShapeInferenceFns = _pywrap_tensorflow_internal.SetRequireShapeInferenceFns

def ExtendSession(session):
    return _pywrap_tensorflow_internal.ExtendSession(session)
ExtendSession = _pywrap_tensorflow_internal.ExtendSession

def GetHandleShapeAndType(graph, output):
    return _pywrap_tensorflow_internal.GetHandleShapeAndType(graph, output)
GetHandleShapeAndType = _pywrap_tensorflow_internal.GetHandleShapeAndType

def SetHandleShapeAndType(graph, output, proto):
    return _pywrap_tensorflow_internal.SetHandleShapeAndType(graph, output, proto)
SetHandleShapeAndType = _pywrap_tensorflow_internal.SetHandleShapeAndType

def AddWhileInputHack(graph, new_src, dst):
    return _pywrap_tensorflow_internal.AddWhileInputHack(graph, new_src, dst)
AddWhileInputHack = _pywrap_tensorflow_internal.AddWhileInputHack

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
    config_str = config.SerializeToString()
    _TF_SetConfig(opts, config_str)
  return opts


def TF_Reset(target, containers=None, config=None):
  from tensorflow.python.framework import errors
  opts = TF_NewSessionOptions(target=target, config=config)
  try:
    TF_Reset_wrapper(opts, containers)
  finally:
    TF_DeleteSessionOptions(opts)


def TF_NewSessionRef(graph, opts):
    return _pywrap_tensorflow_internal.TF_NewSessionRef(graph, opts)
TF_NewSessionRef = _pywrap_tensorflow_internal.TF_NewSessionRef

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_DeprecatedSessionMakeCallable(session, callable_options):
    return _pywrap_tensorflow_internal.TF_DeprecatedSessionMakeCallable(session, callable_options)
TF_DeprecatedSessionMakeCallable = _pywrap_tensorflow_internal.TF_DeprecatedSessionMakeCallable

def TF_SessionMakeCallable(session, callable_options):
    return _pywrap_tensorflow_internal.TF_SessionMakeCallable(session, callable_options)
TF_SessionMakeCallable = _pywrap_tensorflow_internal.TF_SessionMakeCallable

def TF_DeprecatedSessionRunCallable(session, handle, feed_values, run_metadata):
    return _pywrap_tensorflow_internal.TF_DeprecatedSessionRunCallable(session, handle, feed_values, run_metadata)
TF_DeprecatedSessionRunCallable = _pywrap_tensorflow_internal.TF_DeprecatedSessionRunCallable

def TF_SessionRunCallable(session, handle, feed_values, run_metadata):
    return _pywrap_tensorflow_internal.TF_SessionRunCallable(session, handle, feed_values, run_metadata)
TF_SessionRunCallable = _pywrap_tensorflow_internal.TF_SessionRunCallable

def TF_DeprecatedSessionReleaseCallable(session, handle):
    return _pywrap_tensorflow_internal.TF_DeprecatedSessionReleaseCallable(session, handle)
TF_DeprecatedSessionReleaseCallable = _pywrap_tensorflow_internal.TF_DeprecatedSessionReleaseCallable

def TF_SessionReleaseCallable(session, handle):
    return _pywrap_tensorflow_internal.TF_SessionReleaseCallable(session, handle)
TF_SessionReleaseCallable = _pywrap_tensorflow_internal.TF_SessionReleaseCallable

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):
    return _pywrap_tensorflow_internal.TF_Reset_wrapper(opt, containers)
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 EqualAttrValueWrapper(actual, expected):
    return _pywrap_tensorflow_internal.EqualAttrValueWrapper(actual, expected)
EqualAttrValueWrapper = _pywrap_tensorflow_internal.EqualAttrValueWrapper

def TF_GraphGetTensorShapeHelper(graph, output):
    return _pywrap_tensorflow_internal.TF_GraphGetTensorShapeHelper(graph, output)
TF_GraphGetTensorShapeHelper = _pywrap_tensorflow_internal.TF_GraphGetTensorShapeHelper

def TF_SessionRun_wrapper(session, run_options, inputs, outputs, targets, run_metadata):
    return _pywrap_tensorflow_internal.TF_SessionRun_wrapper(session, run_options, inputs, outputs, targets, run_metadata)
TF_SessionRun_wrapper = _pywrap_tensorflow_internal.TF_SessionRun_wrapper

def TF_SessionPRunSetup_wrapper(session, inputs, outputs, targets):
    return _pywrap_tensorflow_internal.TF_SessionPRunSetup_wrapper(session, inputs, outputs, targets)
TF_SessionPRunSetup_wrapper = _pywrap_tensorflow_internal.TF_SessionPRunSetup_wrapper

def TF_SessionPRun_wrapper(session, handle, inputs, outputs):
    return _pywrap_tensorflow_internal.TF_SessionPRun_wrapper(session, handle, inputs, outputs)
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_OperationGetControlOutputs_wrapper(oper):
    return _pywrap_tensorflow_internal.TF_OperationGetControlOutputs_wrapper(oper)
TF_OperationGetControlOutputs_wrapper = _pywrap_tensorflow_internal.TF_OperationGetControlOutputs_wrapper

def TF_OperationOutputConsumers_wrapper(oper_out):
    return _pywrap_tensorflow_internal.TF_OperationOutputConsumers_wrapper(oper_out)
TF_OperationOutputConsumers_wrapper = _pywrap_tensorflow_internal.TF_OperationOutputConsumers_wrapper

def TF_GraphToFunction_wrapper(fn_body, fn_name, append_hash_to_fn_name, opers, inputs, outputs, output_names, control_outputs, control_output_names, opts, description):
    return _pywrap_tensorflow_internal.TF_GraphToFunction_wrapper(fn_body, fn_name, append_hash_to_fn_name, opers, inputs, outputs, output_names, control_outputs, control_output_names, opts, description)
TF_GraphToFunction_wrapper = _pywrap_tensorflow_internal.TF_GraphToFunction_wrapper

def TF_GraphSetOutputHandleShapesAndTypes_wrapper(graph, output, shapes, ranks, types):
    return _pywrap_tensorflow_internal.TF_GraphSetOutputHandleShapesAndTypes_wrapper(graph, output, shapes, ranks, types)
TF_GraphSetOutputHandleShapesAndTypes_wrapper = _pywrap_tensorflow_internal.TF_GraphSetOutputHandleShapesAndTypes_wrapper

def TF_GraphSetTensorShape_wrapper(graph, output, dims, unknown_shape):
    return _pywrap_tensorflow_internal.TF_GraphSetTensorShape_wrapper(graph, output, dims, unknown_shape)
TF_GraphSetTensorShape_wrapper = _pywrap_tensorflow_internal.TF_GraphSetTensorShape_wrapper

def TF_ImportGraphDefResultsMissingUnusedInputMappings_wrapper(results):
    return _pywrap_tensorflow_internal.TF_ImportGraphDefResultsMissingUnusedInputMappings_wrapper(results)
TF_ImportGraphDefResultsMissingUnusedInputMappings_wrapper = _pywrap_tensorflow_internal.TF_ImportGraphDefResultsMissingUnusedInputMappings_wrapper

def TF_TryEvaluateConstant_wrapper(graph, output):
    return _pywrap_tensorflow_internal.TF_TryEvaluateConstant_wrapper(graph, output)
TF_TryEvaluateConstant_wrapper = _pywrap_tensorflow_internal.TF_TryEvaluateConstant_wrapper

def ListDevices():
    return _pywrap_tensorflow_internal.ListDevices()
ListDevices = _pywrap_tensorflow_internal.ListDevices

def ListDevicesWithSessionConfig(config):
    return _pywrap_tensorflow_internal.ListDevicesWithSessionConfig(config)
ListDevicesWithSessionConfig = _pywrap_tensorflow_internal.ListDevicesWithSessionConfig

def list_devices(session_config=None):
  from tensorflow.python.framework import errors

  if session_config:
    return ListDevicesWithSessionConfig(session_config.SerializeToString())
  else:
    return ListDevices()


def TF_bfloat16_type():
    return _pywrap_tensorflow_internal.TF_bfloat16_type()
TF_bfloat16_type = _pywrap_tensorflow_internal.TF_bfloat16_type

def FileExists(filename):
    return _pywrap_tensorflow_internal.FileExists(filename)
FileExists = _pywrap_tensorflow_internal.FileExists

def DeleteFile(filename):
    return _pywrap_tensorflow_internal.DeleteFile(filename)
DeleteFile = _pywrap_tensorflow_internal.DeleteFile

def ReadFileToString(filename):
    return _pywrap_tensorflow_internal.ReadFileToString(filename)
ReadFileToString = _pywrap_tensorflow_internal.ReadFileToString

def WriteStringToFile(filename, file_content):
    return _pywrap_tensorflow_internal.WriteStringToFile(filename, file_content)
WriteStringToFile = _pywrap_tensorflow_internal.WriteStringToFile

def GetChildren(dir):
    return _pywrap_tensorflow_internal.GetChildren(dir)
GetChildren = _pywrap_tensorflow_internal.GetChildren

def GetMatchingFiles(filename):
    return _pywrap_tensorflow_internal.GetMatchingFiles(filename)
GetMatchingFiles = _pywrap_tensorflow_internal.GetMatchingFiles

def CreateDir(dirname):
    return _pywrap_tensorflow_internal.CreateDir(dirname)
CreateDir = _pywrap_tensorflow_internal.CreateDir

def RecursivelyCreateDir(dirname):
    return _pywrap_tensorflow_internal.RecursivelyCreateDir(dirname)
RecursivelyCreateDir = _pywrap_tensorflow_internal.RecursivelyCreateDir

def CopyFile(oldpath, newpath, overwrite):
    return _pywrap_tensorflow_internal.CopyFile(oldpath, newpath, overwrite)
CopyFile = _pywrap_tensorflow_internal.CopyFile

def RenameFile(oldname, newname, overwrite):
    return _pywrap_tensorflow_internal.RenameFile(oldname, newname, overwrite)
RenameFile = _pywrap_tensorflow_internal.RenameFile

def DeleteRecursively(dirname):
    return _pywrap_tensorflow_internal.DeleteRecursively(dirname)
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):
    return _pywrap_tensorflow_internal.Stat(filename, stats)
Stat = _pywrap_tensorflow_internal.Stat

def CreateBufferedInputStream(filename, buffer_size):
    return _pywrap_tensorflow_internal.CreateBufferedInputStream(filename, buffer_size)
CreateBufferedInputStream = _pywrap_tensorflow_internal.CreateBufferedInputStream

def CreateWritableFile(filename, mode):
    return _pywrap_tensorflow_internal.CreateWritableFile(filename, mode)
CreateWritableFile = _pywrap_tensorflow_internal.CreateWritableFile

def AppendToFile(file_content, file):
    return _pywrap_tensorflow_internal.AppendToFile(file_content, file)
AppendToFile = _pywrap_tensorflow_internal.AppendToFile

def TellFile(file):
    return _pywrap_tensorflow_internal.TellFile(file)
TellFile = _pywrap_tensorflow_internal.TellFile

def ReadFromStream(stream, bytes):
    return _pywrap_tensorflow_internal.ReadFromStream(stream, bytes)
ReadFromStream = _pywrap_tensorflow_internal.ReadFromStream
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

def GetTempFilename(extension):
    return _pywrap_tensorflow_internal.GetTempFilename(extension)
GetTempFilename = _pywrap_tensorflow_internal.GetTempFilename
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):
    return _pywrap_tensorflow_internal.DoQuantizeTrainingOnGraphDefHelper(input_graph, num_bits)
DoQuantizeTrainingOnGraphDefHelper = _pywrap_tensorflow_internal.DoQuantizeTrainingOnGraphDefHelper

from tensorflow.python.util import deprecation
from tensorflow.python.util.tf_export import tf_export

@deprecation.deprecated(
    None,
    "GraphDef quantized training rewriter is deprecated in the long term")
@tf_export(v1=["train.do_quantize_training_on_graphdef"])
def do_quantize_training_on_graphdef(input_graph, num_bits):
  """A general quantization scheme is being developed in `tf.contrib.quantize`.

  Consider using that instead, though since it is in the tf.contrib namespace,
  it is not subject to backward compatibility guarantees.
  """
  from tensorflow.core.framework.graph_pb2 import GraphDef
  from tensorflow.python.framework import errors

  graph = GraphDef()
  result_graph_string = DoQuantizeTrainingOnGraphDefHelper(
      input_graph.SerializeToString(), num_bits)

  graph.ParseFromString(result_graph_string)
  return graph

do_quantize_training_on_graphdef._tf_api_names = [
    'train.do_quantize_training_on_graphdef']
do_quantize_training_on_graphdef._tf_api_names_v1 = [
    'train.do_quantize_training_on_graphdef']


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):
    return _pywrap_tensorflow_internal.RunCppShapeInference(graph_def_version, serialized_node_def, input_serialized_shapes, input_constant_tensor_values, input_constant_tensor_as_shape_values)
RunCppShapeInference = _pywrap_tensorflow_internal.RunCppShapeInference

def InstallStacktraceHandler():
    return _pywrap_tensorflow_internal.InstallStacktraceHandler()
InstallStacktraceHandler = _pywrap_tensorflow_internal.InstallStacktraceHandler

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 IsSequence(o):
    """
    Returns true if its input is a collections.Sequence (except strings).

    Args:
      seq: an input sequence.

    Returns:
      True if the sequence is a not a string and is a collections.Sequence or a
      dict.

    """
    return _pywrap_tensorflow_internal.IsSequence(o)

def IsSequenceOrComposite(o):
    """
    Returns true if its input is a sequence or a `CompositeTensor`.

    Args:
      seq: an input sequence.

    Returns:
      True if the sequence is a not a string and is a collections.Sequence or a
      dict or a CompositeTensor.

    """
    return _pywrap_tensorflow_internal.IsSequenceOrComposite(o)

def IsCompositeTensor(o):
    """
    Returns true if its input is a `CompositeTensor`.

    Args:
      seq: an input sequence.

    Returns:
      True if the sequence is a CompositeTensor.

    """
    return _pywrap_tensorflow_internal.IsCompositeTensor(o)

def IsNamedtuple(o, strict):
    return _pywrap_tensorflow_internal.IsNamedtuple(o, strict)
IsNamedtuple = _pywrap_tensorflow_internal.IsNamedtuple

def IsMapping(o):
    """
    Returns True iff `instance` is a `collections.Mapping`.

    Args:
      instance: An instance of a Python object.

    Returns:
      True if `instance` is a `collections.Mapping`.

    """
    return _pywrap_tensorflow_internal.IsMapping(o)

def IsAttrs(o):
    """
    Returns True iff `instance` is an instance of an `attr.s` decorated class.

    Args:
      instance: An instance of a Python object.

    Returns:
      True if `instance` is an instance of an `attr.s` decorated class.

    """
    return _pywrap_tensorflow_internal.IsAttrs(o)

def IsTensor(o):
    return _pywrap_tensorflow_internal.IsTensor(o)
IsTensor = _pywrap_tensorflow_internal.IsTensor

def SameNamedtuples(o1, o2):
    """Returns True if the two namedtuples have the same name and fields."""
    return _pywrap_tensorflow_internal.SameNamedtuples(o1, o2)

def AssertSameStructure(o1, o2, check_types, expand_composites):
    return _pywrap_tensorflow_internal.AssertSameStructure(o1, o2, check_types, expand_composites)
AssertSameStructure = _pywrap_tensorflow_internal.AssertSameStructure

def Flatten(nested, expand_composites=False):
    """
    Returns a flat list from a given nested structure.

    If `nest` is not a sequence, tuple, or dict, then returns a single-element
    list: `[nest]`.

    In the case of dict instances, the sequence consists of the values, sorted by
    key to ensure deterministic behavior. This is true also for `OrderedDict`
    instances: their sequence order is ignored, the sorting order of keys is
    used instead. The same convention is followed in `pack_sequence_as`. This
    correctly repacks dicts and `OrderedDict`s after they have been flattened,
    and also allows flattening an `OrderedDict` and then repacking it back using
    a corresponding plain dict, or vice-versa.
    Dictionaries with non-sortable keys cannot be flattened.

    Users must not modify any collections used in `nest` while this function is
    running.

    Args:
      nest: an arbitrarily nested structure or a scalar object. Note, numpy
          arrays are considered scalars.
      expand_composites: If true, then composite tensors such as `tf.SparseTensor`
          and `tf.RaggedTensor` are expanded into their component tensors.

    Returns:
      A Python list, the flattened version of the input.

    Raises:
      TypeError: The nest is or contains a dict with non-sortable keys.

    """
    return _pywrap_tensorflow_internal.Flatten(nested, expand_composites)

def IsSequenceForData(o):
    """
    Returns a true if `seq` is a Sequence or dict (except strings/lists).

    NOTE(mrry): This differs from `tensorflow.python.util.nest.is_sequence()`,
    which *does* treat a Python list as a sequence. For ergonomic
    reasons, `tf.data` users would prefer to treat lists as
    implicit `tf.Tensor` objects, and dicts as (nested) sequences.

    Args:
      seq: an input sequence.

    Returns:
      True if the sequence is a not a string or list and is a
      collections.Sequence.

    """
    return _pywrap_tensorflow_internal.IsSequenceForData(o)

def FlattenForData(nested):
    """
    Returns a flat sequence from a given nested structure.

    If `nest` is not a sequence, this returns a single-element list: `[nest]`.

    Args:
      nest: an arbitrarily nested structure or a scalar object.
        Note, numpy arrays are considered scalars.

    Returns:
      A Python list, the flattened version of the input.

    """
    return _pywrap_tensorflow_internal.FlattenForData(nested)

def AssertSameStructureForData(o1, o2, check_types):
    return _pywrap_tensorflow_internal.AssertSameStructureForData(o1, o2, check_types)
AssertSameStructureForData = _pywrap_tensorflow_internal.AssertSameStructureForData

def RegisterType(type_name, type):
    return _pywrap_tensorflow_internal.RegisterType(type_name, type)
RegisterType = _pywrap_tensorflow_internal.RegisterType

_pywrap_tensorflow_internal.SHARED_PTR_DISOWN_swigconstant(_pywrap_tensorflow_internal)
SHARED_PTR_DISOWN = _pywrap_tensorflow_internal.SHARED_PTR_DISOWN
class GItem(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GItem, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GItem, name)
    __repr__ = _swig_repr
    __swig_setmethods__["item_"] = _pywrap_tensorflow_internal.GItem_item__set
    __swig_getmethods__["item_"] = _pywrap_tensorflow_internal.GItem_item__get
    if _newclass:
        item_ = _swig_property(_pywrap_tensorflow_internal.GItem_item__get, _pywrap_tensorflow_internal.GItem_item__set)

    def __init__(self):
        this = _pywrap_tensorflow_internal.new_GItem()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _pywrap_tensorflow_internal.delete_GItem
    __del__ = lambda self: None
GItem_swigregister = _pywrap_tensorflow_internal.GItem_swigregister
GItem_swigregister(GItem)


def TF_NewItem(meta_graph, ignore_colocation, ignore_user_placement):
    return _pywrap_tensorflow_internal.TF_NewItem(meta_graph, ignore_colocation, ignore_user_placement)
TF_NewItem = _pywrap_tensorflow_internal.TF_NewItem

def TF_IdentifyImportantOps(item, sort_topologically):
    return _pywrap_tensorflow_internal.TF_IdentifyImportantOps(item, sort_topologically)
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_GetColocationGroups(item):
    return _pywrap_tensorflow_internal.TF_GetColocationGroups(item)
TF_GetColocationGroups = _pywrap_tensorflow_internal.TF_GetColocationGroups
class GCluster(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GCluster, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GCluster, name)
    __repr__ = _swig_repr
    __swig_setmethods__["cluster_"] = _pywrap_tensorflow_internal.GCluster_cluster__set
    __swig_getmethods__["cluster_"] = _pywrap_tensorflow_internal.GCluster_cluster__get
    if _newclass:
        cluster_ = _swig_property(_pywrap_tensorflow_internal.GCluster_cluster__get, _pywrap_tensorflow_internal.GCluster_cluster__set)

    def __init__(self):
        this = _pywrap_tensorflow_internal.new_GCluster()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _pywrap_tensorflow_internal.delete_GCluster
    __del__ = lambda self: None
GCluster_swigregister = _pywrap_tensorflow_internal.GCluster_swigregister
GCluster_swigregister(GCluster)


def TF_NewCluster(allow_soft_placement, disable_detailed_stats):
    return _pywrap_tensorflow_internal.TF_NewCluster(allow_soft_placement, disable_detailed_stats)
TF_NewCluster = _pywrap_tensorflow_internal.TF_NewCluster

def TF_NewVirtualCluster(named_devices):
    return _pywrap_tensorflow_internal.TF_NewVirtualCluster(named_devices)
TF_NewVirtualCluster = _pywrap_tensorflow_internal.TF_NewVirtualCluster

def TF_ShutdownCluster(cluster):
    return _pywrap_tensorflow_internal.TF_ShutdownCluster(cluster)
TF_ShutdownCluster = _pywrap_tensorflow_internal.TF_ShutdownCluster

def TF_ListDevices(cluster):
    return _pywrap_tensorflow_internal.TF_ListDevices(cluster)
TF_ListDevices = _pywrap_tensorflow_internal.TF_ListDevices

def TF_ListAvailableOps():
    return _pywrap_tensorflow_internal.TF_ListAvailableOps()
TF_ListAvailableOps = _pywrap_tensorflow_internal.TF_ListAvailableOps

def TF_GetSupportedDevices(cluster, item):
    return _pywrap_tensorflow_internal.TF_GetSupportedDevices(cluster, item)
TF_GetSupportedDevices = _pywrap_tensorflow_internal.TF_GetSupportedDevices

def TF_EstimatePerformance(device):
    return _pywrap_tensorflow_internal.TF_EstimatePerformance(device)
TF_EstimatePerformance = _pywrap_tensorflow_internal.TF_EstimatePerformance

def TF_MeasureCosts(item, cluster, generate_timeline):
    return _pywrap_tensorflow_internal.TF_MeasureCosts(item, cluster, generate_timeline)
TF_MeasureCosts = _pywrap_tensorflow_internal.TF_MeasureCosts

def TF_DeterminePeakMemoryUsage(item, cluster):
    return _pywrap_tensorflow_internal.TF_DeterminePeakMemoryUsage(item, cluster)
TF_DeterminePeakMemoryUsage = _pywrap_tensorflow_internal.TF_DeterminePeakMemoryUsage

def TF_OptimizeGraph(cluster, config_proto, metagraph, verbose, graph_id):
    return _pywrap_tensorflow_internal.TF_OptimizeGraph(cluster, config_proto, metagraph, verbose, graph_id)
TF_OptimizeGraph = _pywrap_tensorflow_internal.TF_OptimizeGraph

def GenerateCostReport(metagraph, per_node_report, verbose, cluster):
    return _pywrap_tensorflow_internal.GenerateCostReport(metagraph, per_node_report, verbose, cluster)
GenerateCostReport = _pywrap_tensorflow_internal.GenerateCostReport

def GraphAnalyzer(file_path, n):
    return _pywrap_tensorflow_internal.GraphAnalyzer(file_path, n)
GraphAnalyzer = _pywrap_tensorflow_internal.GraphAnalyzer

def GenerateModelReport(metagraph, assume_valid_feeds, debug):
    return _pywrap_tensorflow_internal.GenerateModelReport(metagraph, assume_valid_feeds, debug)
GenerateModelReport = _pywrap_tensorflow_internal.GenerateModelReport
# This file is compatible with both classic and new-style classes.