# 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', [dirname(__file__)])
        except ImportError:
            import _pywrap_tensorflow
            return _pywrap_tensorflow
        if fp is not None:
            try:
                _mod = imp.load_module('_pywrap_tensorflow', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _pywrap_tensorflow = swig_import_helper()
    del swig_import_helper
else:
    import _pywrap_tensorflow
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 IsGoogleCudaEnabled():
    return _pywrap_tensorflow.IsGoogleCudaEnabled()
IsGoogleCudaEnabled = _pywrap_tensorflow.IsGoogleCudaEnabled

def CudaSupportsHalfMatMulAndConv():
    return _pywrap_tensorflow.CudaSupportsHalfMatMulAndConv()
CudaSupportsHalfMatMulAndConv = _pywrap_tensorflow.CudaSupportsHalfMatMulAndConv

def CheckpointReader_GetTensor(reader, name, out_status):
    return _pywrap_tensorflow.CheckpointReader_GetTensor(reader, name, out_status)
CheckpointReader_GetTensor = _pywrap_tensorflow.CheckpointReader_GetTensor

def NewCheckpointReader(filepattern):
  from tensorflow.python.framework import errors
  with errors.raise_exception_on_not_ok_status() as status:
    from tensorflow.python.util import compat
    return CheckpointReader(compat.as_bytes(filepattern), status)

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

    def __init__(self, filepattern, out_status):
        this = _pywrap_tensorflow.new_CheckpointReader(filepattern, out_status)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _pywrap_tensorflow.delete_CheckpointReader
    __del__ = lambda self: None

    def _HasTensor(self, name):
        return _pywrap_tensorflow.CheckpointReader__HasTensor(self, name)

    def debug_string(self):
        return _pywrap_tensorflow.CheckpointReader_debug_string(self)

    def get_variable_to_shape_map(self):
        return _pywrap_tensorflow.CheckpointReader_get_variable_to_shape_map(self)

    def has_tensor(self, tensor_str):
      from tensorflow.python.util import compat
      return self._HasTensor(compat.as_bytes(tensor_str))

    def get_tensor(self, tensor_str):
      from tensorflow.python.framework import errors
      with errors.raise_exception_on_not_ok_status() as status:
        from tensorflow.python.util import compat
        return CheckpointReader_GetTensor(self, compat.as_bytes(tensor_str),
                                          status)

CheckpointReader_swigregister = _pywrap_tensorflow.CheckpointReader_swigregister
CheckpointReader_swigregister(CheckpointReader)


def NewStatSummarizer(graph_def_str):
    return _pywrap_tensorflow.NewStatSummarizer(graph_def_str)
NewStatSummarizer = _pywrap_tensorflow.NewStatSummarizer

def DeleteStatSummarizer(ss):
    return _pywrap_tensorflow.DeleteStatSummarizer(ss)
DeleteStatSummarizer = _pywrap_tensorflow.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

    def ProcessStepStats(self, step_stats):
        return _pywrap_tensorflow.StatSummarizer_ProcessStepStats(self, step_stats)

    def GetOutputString(self):
        return _pywrap_tensorflow.StatSummarizer_GetOutputString(self)

    def PrintStepStats(self):
        return _pywrap_tensorflow.StatSummarizer_PrintStepStats(self)

    def ProcessStepStatsStr(self, step_stats_str):
        return _pywrap_tensorflow.StatSummarizer_ProcessStepStatsStr(self, step_stats_str)

    def __init__(self, *args):
        this = _pywrap_tensorflow.new_StatSummarizer(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _pywrap_tensorflow.delete_StatSummarizer
    __del__ = lambda self: None
StatSummarizer_swigregister = _pywrap_tensorflow.StatSummarizer_swigregister
StatSummarizer_swigregister(StatSummarizer)


def InitializePyTrampoline(trampoline):
    return _pywrap_tensorflow.InitializePyTrampoline(trampoline)
InitializePyTrampoline = _pywrap_tensorflow.InitializePyTrampoline
class PyRecordReader(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PyRecordReader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PyRecordReader, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["New"] = lambda x: _pywrap_tensorflow.PyRecordReader_New
    if _newclass:
        New = staticmethod(_pywrap_tensorflow.PyRecordReader_New)
    __swig_destroy__ = _pywrap_tensorflow.delete_PyRecordReader
    __del__ = lambda self: None

    def GetNext(self, status):
        return _pywrap_tensorflow.PyRecordReader_GetNext(self, status)

    def record(self):
        return _pywrap_tensorflow.PyRecordReader_record(self)

    def offset(self):
        return _pywrap_tensorflow.PyRecordReader_offset(self)

    def Close(self):
        return _pywrap_tensorflow.PyRecordReader_Close(self)
PyRecordReader_swigregister = _pywrap_tensorflow.PyRecordReader_swigregister
PyRecordReader_swigregister(PyRecordReader)

def PyRecordReader_New(filename, start_offset, compression_type_string, out_status):
    return _pywrap_tensorflow.PyRecordReader_New(filename, start_offset, compression_type_string, out_status)
PyRecordReader_New = _pywrap_tensorflow.PyRecordReader_New

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["New"] = lambda x: _pywrap_tensorflow.PyRecordWriter_New
    if _newclass:
        New = staticmethod(_pywrap_tensorflow.PyRecordWriter_New)
    __swig_destroy__ = _pywrap_tensorflow.delete_PyRecordWriter
    __del__ = lambda self: None

    def WriteRecord(self, record):
        return _pywrap_tensorflow.PyRecordWriter_WriteRecord(self, record)

    def Close(self):
        return _pywrap_tensorflow.PyRecordWriter_Close(self)
PyRecordWriter_swigregister = _pywrap_tensorflow.PyRecordWriter_swigregister
PyRecordWriter_swigregister(PyRecordWriter)

def PyRecordWriter_New(filename, compression_type_string, out_status):
    return _pywrap_tensorflow.PyRecordWriter_New(filename, compression_type_string, out_status)
PyRecordWriter_New = _pywrap_tensorflow.PyRecordWriter_New

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

    def __init__(self, file_prefix):
        this = _pywrap_tensorflow.new_EventsWriter(file_prefix)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _pywrap_tensorflow.delete_EventsWriter
    __del__ = lambda self: None

    def FileName(self):
        return _pywrap_tensorflow.EventsWriter_FileName(self)

    def _WriteSerializedEvent(self, event_str):
        return _pywrap_tensorflow.EventsWriter__WriteSerializedEvent(self, event_str)

    def Flush(self):
        return _pywrap_tensorflow.EventsWriter_Flush(self)

    def Close(self):
        return _pywrap_tensorflow.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.EventsWriter_swigregister
EventsWriter_swigregister(EventsWriter)


_pywrap_tensorflow.__version___swigconstant(_pywrap_tensorflow)
__version__ = _pywrap_tensorflow.__version__

_pywrap_tensorflow.GRAPH_DEF_VERSION_swigconstant(_pywrap_tensorflow)
GRAPH_DEF_VERSION = _pywrap_tensorflow.GRAPH_DEF_VERSION

_pywrap_tensorflow.GRAPH_DEF_VERSION_MIN_CONSUMER_swigconstant(_pywrap_tensorflow)
GRAPH_DEF_VERSION_MIN_CONSUMER = _pywrap_tensorflow.GRAPH_DEF_VERSION_MIN_CONSUMER

_pywrap_tensorflow.GRAPH_DEF_VERSION_MIN_PRODUCER_swigconstant(_pywrap_tensorflow)
GRAPH_DEF_VERSION_MIN_PRODUCER = _pywrap_tensorflow.GRAPH_DEF_VERSION_MIN_PRODUCER

_pywrap_tensorflow.__git_version___swigconstant(_pywrap_tensorflow)
__git_version__ = _pywrap_tensorflow.__git_version__

_pywrap_tensorflow.__compiler_version___swigconstant(_pywrap_tensorflow)
__compiler_version__ = _pywrap_tensorflow.__compiler_version__

def TF_NewStatus():
    return _pywrap_tensorflow.TF_NewStatus()
TF_NewStatus = _pywrap_tensorflow.TF_NewStatus

def TF_DeleteStatus(arg1):
    return _pywrap_tensorflow.TF_DeleteStatus(arg1)
TF_DeleteStatus = _pywrap_tensorflow.TF_DeleteStatus

def TF_GetCode(s):
    return _pywrap_tensorflow.TF_GetCode(s)
TF_GetCode = _pywrap_tensorflow.TF_GetCode

def TF_Message(s):
    return _pywrap_tensorflow.TF_Message(s)
TF_Message = _pywrap_tensorflow.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

    def __init__(self):
        this = _pywrap_tensorflow.new_TF_Buffer()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _pywrap_tensorflow.delete_TF_Buffer
    __del__ = lambda self: None
TF_Buffer_swigregister = _pywrap_tensorflow.TF_Buffer_swigregister
TF_Buffer_swigregister(TF_Buffer)


def TF_NewBufferFromString(proto):
    return _pywrap_tensorflow.TF_NewBufferFromString(proto)
TF_NewBufferFromString = _pywrap_tensorflow.TF_NewBufferFromString

def TF_NewBuffer():
    return _pywrap_tensorflow.TF_NewBuffer()
TF_NewBuffer = _pywrap_tensorflow.TF_NewBuffer

def TF_DeleteBuffer(arg1):
    return _pywrap_tensorflow.TF_DeleteBuffer(arg1)
TF_DeleteBuffer = _pywrap_tensorflow.TF_DeleteBuffer

def TF_GetBuffer(buffer):
    return _pywrap_tensorflow.TF_GetBuffer(buffer)
TF_GetBuffer = _pywrap_tensorflow.TF_GetBuffer

def _TF_NewSessionOptions():
    return _pywrap_tensorflow._TF_NewSessionOptions()
_TF_NewSessionOptions = _pywrap_tensorflow._TF_NewSessionOptions

def _TF_SetTarget(options, target):
    return _pywrap_tensorflow._TF_SetTarget(options, target)
_TF_SetTarget = _pywrap_tensorflow._TF_SetTarget

def _TF_SetConfig(options, proto, status):
    return _pywrap_tensorflow._TF_SetConfig(options, proto, status)
_TF_SetConfig = _pywrap_tensorflow._TF_SetConfig

def TF_DeleteSessionOptions(arg1):
    return _pywrap_tensorflow.TF_DeleteSessionOptions(arg1)
TF_DeleteSessionOptions = _pywrap_tensorflow.TF_DeleteSessionOptions

def TF_NewDeprecatedSession(arg1, status):
    return _pywrap_tensorflow.TF_NewDeprecatedSession(arg1, status)
TF_NewDeprecatedSession = _pywrap_tensorflow.TF_NewDeprecatedSession

def TF_CloseDeprecatedSession(arg1, status):
    return _pywrap_tensorflow.TF_CloseDeprecatedSession(arg1, status)
TF_CloseDeprecatedSession = _pywrap_tensorflow.TF_CloseDeprecatedSession

def TF_DeleteDeprecatedSession(arg1, status):
    return _pywrap_tensorflow.TF_DeleteDeprecatedSession(arg1, status)
TF_DeleteDeprecatedSession = _pywrap_tensorflow.TF_DeleteDeprecatedSession

def TF_ExtendGraph(arg1, proto, arg3):
    return _pywrap_tensorflow.TF_ExtendGraph(arg1, proto, arg3)
TF_ExtendGraph = _pywrap_tensorflow.TF_ExtendGraph

def TF_LoadLibrary(library_filename, status):
    return _pywrap_tensorflow.TF_LoadLibrary(library_filename, status)
TF_LoadLibrary = _pywrap_tensorflow.TF_LoadLibrary

def TF_GetOpList(lib_handle):
    return _pywrap_tensorflow.TF_GetOpList(lib_handle)
TF_GetOpList = _pywrap_tensorflow.TF_GetOpList

def TF_NewSessionOptions(target=None, config=None):
# NOTE: target and config are validated in the session constructor.
  opts = _TF_NewSessionOptions()
  if target is not None:
    _TF_SetTarget(opts, target)
  if config is not None:
    from tensorflow.python.framework import errors
    with errors.raise_exception_on_not_ok_status() as status:
      config_str = config.SerializeToString()
      _TF_SetConfig(opts, config_str, status)
  return opts


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


def TF_Run(session, run_options, feed_dict, output_names, target_nodes, out_status, run_outputs):
    return _pywrap_tensorflow.TF_Run(session, run_options, feed_dict, output_names, target_nodes, out_status, run_outputs)
TF_Run = _pywrap_tensorflow.TF_Run

def TF_PRunSetup(session, input_names, output_names, target_nodes, out_status):
    return _pywrap_tensorflow.TF_PRunSetup(session, input_names, output_names, target_nodes, out_status)
TF_PRunSetup = _pywrap_tensorflow.TF_PRunSetup

def TF_PRun(session, handle, feed_dict, output_names, out_status):
    return _pywrap_tensorflow.TF_PRun(session, handle, feed_dict, output_names, out_status)
TF_PRun = _pywrap_tensorflow.TF_PRun

def TF_Reset_wrapper(opt, containers, out_status):
    return _pywrap_tensorflow.TF_Reset_wrapper(opt, containers, out_status)
TF_Reset_wrapper = _pywrap_tensorflow.TF_Reset_wrapper

def EqualGraphDefWrapper(actual, expected):
    return _pywrap_tensorflow.EqualGraphDefWrapper(actual, expected)
EqualGraphDefWrapper = _pywrap_tensorflow.EqualGraphDefWrapper

def ListDevices(out_status):
    return _pywrap_tensorflow.ListDevices(out_status)
ListDevices = _pywrap_tensorflow.ListDevices

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

  with errors.raise_exception_on_not_ok_status() as status:
    return ListDevices(status)


def DoQuantizeTrainingOnGraphDefHelper(input_graph, num_bits, out_status):
    return _pywrap_tensorflow.DoQuantizeTrainingOnGraphDefHelper(input_graph, num_bits, out_status)
DoQuantizeTrainingOnGraphDefHelper = _pywrap_tensorflow.DoQuantizeTrainingOnGraphDefHelper

def do_quantize_training_on_graphdef(input_graph, num_bits):
  from tensorflow.core.framework.graph_pb2 import GraphDef
  from tensorflow.python.framework import errors
  with errors.raise_exception_on_not_ok_status() as status:
    graph = GraphDef()
    result_graph_string = DoQuantizeTrainingOnGraphDefHelper(
        input_graph.SerializeToString(), num_bits, status)

  graph.ParseFromString(result_graph_string)
  return graph


def FileExists(filename, out_status):
    return _pywrap_tensorflow.FileExists(filename, out_status)
FileExists = _pywrap_tensorflow.FileExists

def DeleteFile(filename, out_status):
    return _pywrap_tensorflow.DeleteFile(filename, out_status)
DeleteFile = _pywrap_tensorflow.DeleteFile

def ReadFileToString(filename, out_status):
    return _pywrap_tensorflow.ReadFileToString(filename, out_status)
ReadFileToString = _pywrap_tensorflow.ReadFileToString

def WriteStringToFile(filename, file_content, out_status):
    return _pywrap_tensorflow.WriteStringToFile(filename, file_content, out_status)
WriteStringToFile = _pywrap_tensorflow.WriteStringToFile

def GetChildren(dir, out_status):
    return _pywrap_tensorflow.GetChildren(dir, out_status)
GetChildren = _pywrap_tensorflow.GetChildren

def GetMatchingFiles(filename, out_status):
    return _pywrap_tensorflow.GetMatchingFiles(filename, out_status)
GetMatchingFiles = _pywrap_tensorflow.GetMatchingFiles

def CreateDir(dirname, out_status):
    return _pywrap_tensorflow.CreateDir(dirname, out_status)
CreateDir = _pywrap_tensorflow.CreateDir

def RecursivelyCreateDir(dirname, out_status):
    return _pywrap_tensorflow.RecursivelyCreateDir(dirname, out_status)
RecursivelyCreateDir = _pywrap_tensorflow.RecursivelyCreateDir

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

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

def DeleteRecursively(dirname, out_status):
    return _pywrap_tensorflow.DeleteRecursively(dirname, out_status)
DeleteRecursively = _pywrap_tensorflow.DeleteRecursively

def IsDirectory(dirname, out_status):
    return _pywrap_tensorflow.IsDirectory(dirname, out_status)
IsDirectory = _pywrap_tensorflow.IsDirectory

def Stat(filename, stats, out_status):
    return _pywrap_tensorflow.Stat(filename, stats, out_status)
Stat = _pywrap_tensorflow.Stat

def CreateBufferedInputStream(filename, buffer_size, out_status):
    return _pywrap_tensorflow.CreateBufferedInputStream(filename, buffer_size, out_status)
CreateBufferedInputStream = _pywrap_tensorflow.CreateBufferedInputStream

def CreateWritableFile(filename, mode, out_status):
    return _pywrap_tensorflow.CreateWritableFile(filename, mode, out_status)
CreateWritableFile = _pywrap_tensorflow.CreateWritableFile

def AppendToFile(file_content, file, out_status):
    return _pywrap_tensorflow.AppendToFile(file_content, file, out_status)
AppendToFile = _pywrap_tensorflow.AppendToFile

def ReadFromStream(stream, bytes, out_status):
    return _pywrap_tensorflow.ReadFromStream(stream, bytes, out_status)
ReadFromStream = _pywrap_tensorflow.ReadFromStream
class Status(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Status, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Status, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _pywrap_tensorflow.delete_Status
    __del__ = lambda self: None

    def __init__(self, *args):
        this = _pywrap_tensorflow.new_Status(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_getmethods__["OK"] = lambda x: _pywrap_tensorflow.Status_OK
    if _newclass:
        OK = staticmethod(_pywrap_tensorflow.Status_OK)

    def ok(self):
        return _pywrap_tensorflow.Status_ok(self)

    def code(self):
        return _pywrap_tensorflow.Status_code(self)

    def error_message(self):
        return _pywrap_tensorflow.Status_error_message(self)

    def __eq__(self, x):
        return _pywrap_tensorflow.Status___eq__(self, x)

    def __ne__(self, x):
        return _pywrap_tensorflow.Status___ne__(self, x)

    def Update(self, new_status):
        return _pywrap_tensorflow.Status_Update(self, new_status)

    def ToString(self):
        return _pywrap_tensorflow.Status_ToString(self)
Status_swigregister = _pywrap_tensorflow.Status_swigregister
Status_swigregister(Status)

def Status_OK():
    return _pywrap_tensorflow.Status_OK()
Status_OK = _pywrap_tensorflow.Status_OK


def __lshift__(os, x):
    return _pywrap_tensorflow.__lshift__(os, x)
__lshift__ = _pywrap_tensorflow.__lshift__
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.delete_WritableFile
    __del__ = lambda self: None

    def Close(self):
        return _pywrap_tensorflow.WritableFile_Close(self)

    def Flush(self):
        return _pywrap_tensorflow.WritableFile_Flush(self)
WritableFile_swigregister = _pywrap_tensorflow.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.delete_BufferedInputStream
    __del__ = lambda self: None

    def Tell(self):
        return _pywrap_tensorflow.BufferedInputStream_Tell(self)

    def Seek(self, position):
        return _pywrap_tensorflow.BufferedInputStream_Seek(self, position)

    def ReadLineAsString(self):
        return _pywrap_tensorflow.BufferedInputStream_ReadLineAsString(self)
BufferedInputStream_swigregister = _pywrap_tensorflow.BufferedInputStream_swigregister
BufferedInputStream_swigregister(BufferedInputStream)


def Set_TF_Status_from_Status(tf_status, status):
    return _pywrap_tensorflow.Set_TF_Status_from_Status(tf_status, status)
Set_TF_Status_from_Status = _pywrap_tensorflow.Set_TF_Status_from_Status

def IsAbsolutePath(path):
    return _pywrap_tensorflow.IsAbsolutePath(path)
IsAbsolutePath = _pywrap_tensorflow.IsAbsolutePath

def Dirname(path):
    return _pywrap_tensorflow.Dirname(path)
Dirname = _pywrap_tensorflow.Dirname

def Basename(path):
    return _pywrap_tensorflow.Basename(path)
Basename = _pywrap_tensorflow.Basename

def Extension(path):
    return _pywrap_tensorflow.Extension(path)
Extension = _pywrap_tensorflow.Extension

def CleanPath(path):
    return _pywrap_tensorflow.CleanPath(path)
CleanPath = _pywrap_tensorflow.CleanPath

def ParseURI(uri, scheme, host, path):
    return _pywrap_tensorflow.ParseURI(uri, scheme, host, path)
ParseURI = _pywrap_tensorflow.ParseURI

def CreateURI(scheme, host, path):
    return _pywrap_tensorflow.CreateURI(scheme, host, path)
CreateURI = _pywrap_tensorflow.CreateURI
class FileStatistics(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FileStatistics, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FileStatistics, name)
    __repr__ = _swig_repr
    __swig_setmethods__["length"] = _pywrap_tensorflow.FileStatistics_length_set
    __swig_getmethods__["length"] = _pywrap_tensorflow.FileStatistics_length_get
    if _newclass:
        length = _swig_property(_pywrap_tensorflow.FileStatistics_length_get, _pywrap_tensorflow.FileStatistics_length_set)
    __swig_setmethods__["mtime_nsec"] = _pywrap_tensorflow.FileStatistics_mtime_nsec_set
    __swig_getmethods__["mtime_nsec"] = _pywrap_tensorflow.FileStatistics_mtime_nsec_get
    if _newclass:
        mtime_nsec = _swig_property(_pywrap_tensorflow.FileStatistics_mtime_nsec_get, _pywrap_tensorflow.FileStatistics_mtime_nsec_set)
    __swig_setmethods__["is_directory"] = _pywrap_tensorflow.FileStatistics_is_directory_set
    __swig_getmethods__["is_directory"] = _pywrap_tensorflow.FileStatistics_is_directory_get
    if _newclass:
        is_directory = _swig_property(_pywrap_tensorflow.FileStatistics_is_directory_get, _pywrap_tensorflow.FileStatistics_is_directory_set)

    def __init__(self, *args):
        this = _pywrap_tensorflow.new_FileStatistics(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _pywrap_tensorflow.delete_FileStatistics
    __del__ = lambda self: None
FileStatistics_swigregister = _pywrap_tensorflow.FileStatistics_swigregister
FileStatistics_swigregister(FileStatistics)


def PyServer_New(server_def, out_status):
    return _pywrap_tensorflow.PyServer_New(server_def, out_status)
PyServer_New = _pywrap_tensorflow.PyServer_New

def PyServer_Start(in_server, out_status):
    return _pywrap_tensorflow.PyServer_Start(in_server, out_status)
PyServer_Start = _pywrap_tensorflow.PyServer_Start

def PyServer_Stop(in_server, out_status):
    return _pywrap_tensorflow.PyServer_Stop(in_server, out_status)
PyServer_Stop = _pywrap_tensorflow.PyServer_Stop

def PyServer_Join(in_server, out_status):
    return _pywrap_tensorflow.PyServer_Join(in_server, out_status)
PyServer_Join = _pywrap_tensorflow.PyServer_Join
class ServerInterface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ServerInterface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ServerInterface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _pywrap_tensorflow.delete_ServerInterface
    __del__ = lambda self: None

    def target(self):
        return _pywrap_tensorflow.ServerInterface_target(self)
ServerInterface_swigregister = _pywrap_tensorflow.ServerInterface_swigregister
ServerInterface_swigregister(ServerInterface)


def GetPythonWrappers(op_wrapper_buf):
    return _pywrap_tensorflow.GetPythonWrappers(op_wrapper_buf)
GetPythonWrappers = _pywrap_tensorflow.GetPythonWrappers

def RunCppShapeInference(graph_def_version, serialized_node_def, input_serialized_shapes, input_constant_tensor_values, input_constant_tensor_as_shape_values, out_status):
    return _pywrap_tensorflow.RunCppShapeInference(graph_def_version, serialized_node_def, input_serialized_shapes, input_constant_tensor_values, input_constant_tensor_as_shape_values, out_status)
RunCppShapeInference = _pywrap_tensorflow.RunCppShapeInference

def TryFindKernelClass(serialized_node_def):
    return _pywrap_tensorflow.TryFindKernelClass(serialized_node_def)
TryFindKernelClass = _pywrap_tensorflow.TryFindKernelClass
# This file is compatible with both classic and new-style classes.


