tensorbored 2.21.0rc1769983804__py3-none-any.whl

tensorbored/compat/tensorflow_stub/error_codes.py

@@ -0,0 +1,169 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+# Contains error codes defined in tensorflow/core/lib/core/error_codes.proto
+
+# Not an error; returned on success
+OK = 0
+
+# The operation was cancelled (typically by the caller).
+CANCELLED = 1
+
+"""
+Unknown error.  An example of where this error may be returned is
+if a Status value received from another address space belongs to
+an error-space that is not known in this address space.  Also
+errors raised by APIs that do not return enough error information
+may be converted to this error.
+"""
+UNKNOWN = 2
+
+"""
+Client specified an invalid argument.  Note that this differs
+from FAILED_PRECONDITION.  INVALID_ARGUMENT indicates arguments
+that are problematic regardless of the state of the system
+(e.g., a malformed file name).
+"""
+INVALID_ARGUMENT = 3
+
+"""
+Deadline expired before operation could complete.  For operations
+that change the state of the system, this error may be returned
+even if the operation has completed successfully.  For example, a
+successful response from a server could have been delayed long
+enough for the deadline to expire.
+"""
+DEADLINE_EXCEEDED = 4
+
+"""
+Some requested entity (e.g., file or directory) was not found.
+For privacy reasons, this code *may* be returned when the client
+does not have the access right to the entity.
+"""
+NOT_FOUND = 5
+
+"""
+Some entity that we attempted to create (e.g., file or directory)
+already exists.
+"""
+ALREADY_EXISTS = 6
+
+"""
+The caller does not have permission to execute the specified
+operation.  PERMISSION_DENIED must not be used for rejections
+caused by exhausting some resource (use RESOURCE_EXHAUSTED
+instead for those errors).  PERMISSION_DENIED must not be
+used if the caller can not be identified (use UNAUTHENTICATED
+instead for those errors).
+"""
+PERMISSION_DENIED = 7
+
+"""
+Some resource has been exhausted, perhaps a per-user quota, or
+perhaps the entire file system is out of space.
+"""
+RESOURCE_EXHAUSTED = 8
+
+"""
+Operation was rejected because the system is not in a state
+required for the operation's execution.  For example, directory
+to be deleted may be non-empty, an rmdir operation is applied to
+a non-directory, etc.
+A litmus test that may help a service implementor in deciding
+between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE:
+(a) Use UNAVAILABLE if the client can retry just the failing call.
+(b) Use ABORTED if the client should retry at a higher-level
+    (e.g., restarting a read-modify-write sequence).
+(c) Use FAILED_PRECONDITION if the client should not retry until
+    the system state has been explicitly fixed.  E.g., if an "rmdir"
+    fails because the directory is non-empty, FAILED_PRECONDITION
+    should be returned since the client should not retry unless
+    they have first fixed up the directory by deleting files from it.
+(d) Use FAILED_PRECONDITION if the client performs conditional
+    REST Get/Update/Delete on a resource and the resource on the
+    server does not match the condition. E.g., conflicting
+    read-modify-write on the same resource.
+"""
+FAILED_PRECONDITION = 9
+
+"""
+The operation was aborted, typically due to a concurrency issue
+like sequencer check failures, transaction aborts, etc.
+
+See litmus test above for deciding between FAILED_PRECONDITION,
+ABORTED, and UNAVAILABLE.
+"""
+ABORTED = 10
+
+"""
+Operation tried to iterate past the valid input range.  E.g., seeking or
+reading past end of file.
+
+Unlike INVALID_ARGUMENT, this error indicates a problem that may
+be fixed if the system state changes. For example, a 32-bit file
+system will generate INVALID_ARGUMENT if asked to read at an
+offset that is not in the range [0,2^32-1], but it will generate
+OUT_OF_RANGE if asked to read from an offset past the current
+file size.
+
+There is a fair bit of overlap between FAILED_PRECONDITION and
+OUT_OF_RANGE.  We recommend using OUT_OF_RANGE (the more specific
+error) when it applies so that callers who are iterating through
+a space can easily look for an OUT_OF_RANGE error to detect when
+they are done.
+"""
+OUT_OF_RANGE = 11
+
+# Operation is not implemented or not supported/enabled in this service.
+UNIMPLEMENTED = 12
+
+"""
+Internal errors.  Means some invariant expected by the underlying
+system has been broken.  If you see one of these errors,
+something is very broken.
+"""
+INTERNAL = 13
+
+"""
+The service is currently unavailable.  This is a most likely a
+transient condition and may be corrected by retrying with
+a backoff.
+
+See litmus test above for deciding between FAILED_PRECONDITION,
+ABORTED, and UNAVAILABLE.
+"""
+UNAVAILABLE = 14
+
+# Unrecoverable data loss or corruption.
+DATA_LOSS = 15
+
+"""
+The request does not have valid authentication credentials for the
+operation.
+"""
+UNAUTHENTICATED = 16
+
+"""
+An extra enum entry to prevent people from writing code that
+fails to compile when a new code is added.
+
+Nobody should ever reference this enumeration entry. In particular,
+if you write C++ code that switches on this enumeration, add a default:
+case instead of a case that mentions this enumeration entry.
+
+Nobody should rely on the value (currently 20) listed here.  It
+may change in the future.
+"""
+DO_NOT_USE_RESERVED_FOR_FUTURE_EXPANSION_USE_DEFAULT_IN_SWITCH_INSTEAD_ = 20

tensorbored/compat/tensorflow_stub/errors.py

@@ -0,0 +1,507 @@
+# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Exception types for TensorFlow errors."""
+
+import traceback
+import warnings
+
+from . import error_codes
+
+
+# @tf_export("OpError", "errors.OpError")
+class OpError(Exception):
+    """A generic error that is raised when TensorFlow execution fails.
+
+    Whenever possible, the session will raise a more specific subclass
+    of `OpError` from the `tf.errors` module.
+    """
+
+    def __init__(self, node_def, op, message, error_code):
+        """Creates a new `OpError` indicating that a particular op failed.
+
+        Args:
+          node_def: The `node_def_pb2.NodeDef` proto representing the op that
+            failed, if known; otherwise None.
+          op: The `ops.Operation` that failed, if known; otherwise None.
+          message: The message string describing the failure.
+          error_code: The `error_codes.Code` describing the error.
+        """
+        super().__init__()
+        self._message = message
+        self._node_def = node_def
+        self._op = op
+        self._error_code = error_code
+
+    @property
+    def message(self):
+        """The error message that describes the error."""
+        return self._message
+
+    @property
+    def op(self):
+        """The operation that failed, if known.
+
+        *N.B.* If the failed op was synthesized at runtime, e.g. a `Send`
+        or `Recv` op, there will be no corresponding
+        @{tf.Operation}
+        object.  In that case, this will return `None`, and you should
+        instead use the @{tf.OpError.node_def} to
+        discover information about the op.
+
+        Returns:
+          The `Operation` that failed, or None.
+        """
+        return self._op
+
+    @property
+    def error_code(self):
+        """The integer error code that describes the error."""
+        return self._error_code
+
+    @property
+    def node_def(self):
+        """The `NodeDef` proto representing the op that failed."""
+        return self._node_def
+
+    def __str__(self):
+        if self._op is not None:
+            output = [
+                "%s\n\nCaused by op %r, defined at:\n"
+                % (self.message, self._op.name)
+            ]
+            curr_traceback_list = traceback.format_list(self._op.traceback)
+            output.extend(curr_traceback_list)
+            # pylint: disable=protected-access
+            original_op = self._op._original_op
+            # pylint: enable=protected-access
+            while original_op is not None:
+                output.append(
+                    "\n...which was originally created as op %r, defined at:\n"
+                    % (original_op.name,)
+                )
+                prev_traceback_list = curr_traceback_list
+                curr_traceback_list = traceback.format_list(
+                    original_op.traceback
+                )
+
+                # Attempt to elide large common subsequences of the subsequent
+                # stack traces.
+                #
+                # TODO(mrry): Consider computing the actual longest common subsequence.
+                is_eliding = False
+                elide_count = 0
+                last_elided_line = None
+                for line, line_in_prev in zip(
+                    curr_traceback_list, prev_traceback_list
+                ):
+                    if line == line_in_prev:
+                        if is_eliding:
+                            elide_count += 1
+                            last_elided_line = line
+                        else:
+                            output.append(line)
+                            is_eliding = True
+                            elide_count = 0
+                    else:
+                        if is_eliding:
+                            if elide_count > 0:
+                                output.extend(
+                                    [
+                                        "[elided %d identical lines from previous traceback]\n"
+                                        % (elide_count - 1,),
+                                        last_elided_line,
+                                    ]
+                                )
+                            is_eliding = False
+                        output.extend(line)
+
+                # pylint: disable=protected-access
+                original_op = original_op._original_op
+                # pylint: enable=protected-access
+            output.append(
+                "\n%s (see above for traceback): %s\n"
+                % (type(self).__name__, self.message)
+            )
+            return "".join(output)
+        else:
+            return self.message
+
+
+OK = error_codes.OK
+# tf_export("errors.OK").export_constant(__name__, "OK")
+CANCELLED = error_codes.CANCELLED
+# tf_export("errors.CANCELLED").export_constant(__name__, "CANCELLED")
+UNKNOWN = error_codes.UNKNOWN
+# tf_export("errors.UNKNOWN").export_constant(__name__, "UNKNOWN")
+INVALID_ARGUMENT = error_codes.INVALID_ARGUMENT
+# tf_export("errors.INVALID_ARGUMENT").export_constant(__name__,
+# "INVALID_ARGUMENT")
+DEADLINE_EXCEEDED = error_codes.DEADLINE_EXCEEDED
+# tf_export("errors.DEADLINE_EXCEEDED").export_constant(__name__,
+# "DEADLINE_EXCEEDED")
+NOT_FOUND = error_codes.NOT_FOUND
+# tf_export("errors.NOT_FOUND").export_constant(__name__, "NOT_FOUND")
+ALREADY_EXISTS = error_codes.ALREADY_EXISTS
+# tf_export("errors.ALREADY_EXISTS").export_constant(__name__, "ALREADY_EXISTS")
+PERMISSION_DENIED = error_codes.PERMISSION_DENIED
+# tf_export("errors.PERMISSION_DENIED").export_constant(__name__,
+# "PERMISSION_DENIED")
+UNAUTHENTICATED = error_codes.UNAUTHENTICATED
+# tf_export("errors.UNAUTHENTICATED").export_constant(__name__, "UNAUTHENTICATED")
+RESOURCE_EXHAUSTED = error_codes.RESOURCE_EXHAUSTED
+# tf_export("errors.RESOURCE_EXHAUSTED").export_constant(__name__,
+# "RESOURCE_EXHAUSTED")
+FAILED_PRECONDITION = error_codes.FAILED_PRECONDITION
+# tf_export("errors.FAILED_PRECONDITION").export_constant(__name__,
+# "FAILED_PRECONDITION")
+ABORTED = error_codes.ABORTED
+# tf_export("errors.ABORTED").export_constant(__name__, "ABORTED")
+OUT_OF_RANGE = error_codes.OUT_OF_RANGE
+# tf_export("errors.OUT_OF_RANGE").export_constant(__name__, "OUT_OF_RANGE")
+UNIMPLEMENTED = error_codes.UNIMPLEMENTED
+# tf_export("errors.UNIMPLEMENTED").export_constant(__name__, "UNIMPLEMENTED")
+INTERNAL = error_codes.INTERNAL
+# tf_export("errors.INTERNAL").export_constant(__name__, "INTERNAL")
+UNAVAILABLE = error_codes.UNAVAILABLE
+# tf_export("errors.UNAVAILABLE").export_constant(__name__, "UNAVAILABLE")
+DATA_LOSS = error_codes.DATA_LOSS
+# tf_export("errors.DATA_LOSS").export_constant(__name__, "DATA_LOSS")
+
+
+# @tf_export("errors.CancelledError")
+class CancelledError(OpError):
+    """Raised when an operation or step is cancelled.
+
+    For example, a long-running operation (e.g.
+    @{tf.QueueBase.enqueue} may be
+    cancelled by running another operation (e.g.
+    @{tf.QueueBase.close},
+    or by @{tf.Session.close}.
+    A step that is running such a long-running operation will fail by raising
+    `CancelledError`.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message):
+        """Creates a `CancelledError`."""
+        super().__init__(node_def, op, message, CANCELLED)
+
+
+# @tf_export("errors.UnknownError")
+class UnknownError(OpError):
+    """Unknown error.
+
+    An example of where this error may be returned is if a Status value
+    received from another address space belongs to an error-space that
+    is not known to this address space. Also errors raised by APIs that
+    do not return enough error information may be converted to this
+    error.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message, error_code=UNKNOWN):
+        """Creates an `UnknownError`."""
+        super().__init__(node_def, op, message, error_code)
+
+
+# @tf_export("errors.InvalidArgumentError")
+class InvalidArgumentError(OpError):
+    """Raised when an operation receives an invalid argument.
+
+    This may occur, for example, if an operation is receives an input
+    tensor that has an invalid value or shape. For example, the
+    @{tf.matmul} op will raise this
+    error if it receives an input that is not a matrix, and the
+    @{tf.reshape} op will raise
+    this error if the new shape does not match the number of elements in the input
+    tensor.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message):
+        """Creates an `InvalidArgumentError`."""
+        super().__init__(node_def, op, message, INVALID_ARGUMENT)
+
+
+# @tf_export("errors.DeadlineExceededError")
+class DeadlineExceededError(OpError):
+    """Raised when a deadline expires before an operation could complete.
+
+    This exception is not currently used.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message):
+        """Creates a `DeadlineExceededError`."""
+        super().__init__(node_def, op, message, DEADLINE_EXCEEDED)
+
+
+# @tf_export("errors.NotFoundError")
+class NotFoundError(OpError):
+    """Raised when a requested entity (e.g., a file or directory) was not
+    found.
+
+    For example, running the
+    @{tf.WholeFileReader.read}
+    operation could raise `NotFoundError` if it receives the name of a file that
+    does not exist.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message):
+        """Creates a `NotFoundError`."""
+        super().__init__(node_def, op, message, NOT_FOUND)
+
+
+# @tf_export("errors.AlreadyExistsError")
+class AlreadyExistsError(OpError):
+    """Raised when an entity that we attempted to create already exists.
+
+    For example, running an operation that saves a file
+    (e.g. @{tf.train.Saver.save})
+    could potentially raise this exception if an explicit filename for an
+    existing file was passed.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message):
+        """Creates an `AlreadyExistsError`."""
+        super().__init__(node_def, op, message, ALREADY_EXISTS)
+
+
+# @tf_export("errors.PermissionDeniedError")
+class PermissionDeniedError(OpError):
+    """Raised when the caller does not have permission to run an operation.
+
+    For example, running the
+    @{tf.WholeFileReader.read}
+    operation could raise `PermissionDeniedError` if it receives the name of a
+    file for which the user does not have the read file permission.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message):
+        """Creates a `PermissionDeniedError`."""
+        super().__init__(node_def, op, message, PERMISSION_DENIED)
+
+
+# @tf_export("errors.UnauthenticatedError")
+class UnauthenticatedError(OpError):
+    """The request does not have valid authentication credentials.
+
+    This exception is not currently used.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message):
+        """Creates an `UnauthenticatedError`."""
+        super().__init__(node_def, op, message, UNAUTHENTICATED)
+
+
+# @tf_export("errors.ResourceExhaustedError")
+class ResourceExhaustedError(OpError):
+    """Some resource has been exhausted.
+
+    For example, this error might be raised if a per-user quota is
+    exhausted, or perhaps the entire file system is out of space.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message):
+        """Creates a `ResourceExhaustedError`."""
+        super().__init__(node_def, op, message, RESOURCE_EXHAUSTED)
+
+
+# @tf_export("errors.FailedPreconditionError")
+class FailedPreconditionError(OpError):
+    """Operation was rejected because the system is not in a state to execute
+    it.
+
+    This exception is most commonly raised when running an operation
+    that reads a @{tf.Variable}
+    before it has been initialized.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message):
+        """Creates a `FailedPreconditionError`."""
+        super().__init__(node_def, op, message, FAILED_PRECONDITION)
+
+
+# @tf_export("errors.AbortedError")
+class AbortedError(OpError):
+    """The operation was aborted, typically due to a concurrent action.
+
+    For example, running a
+    @{tf.QueueBase.enqueue}
+    operation may raise `AbortedError` if a
+    @{tf.QueueBase.close} operation
+    previously ran.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message):
+        """Creates an `AbortedError`."""
+        super().__init__(node_def, op, message, ABORTED)
+
+
+# @tf_export("errors.OutOfRangeError")
+class OutOfRangeError(OpError):
+    """Raised when an operation iterates past the valid input range.
+
+    This exception is raised in "end-of-file" conditions, such as when a
+    @{tf.QueueBase.dequeue}
+    operation is blocked on an empty queue, and a
+    @{tf.QueueBase.close}
+    operation executes.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message):
+        """Creates an `OutOfRangeError`."""
+        super().__init__(node_def, op, message, OUT_OF_RANGE)
+
+
+# @tf_export("errors.UnimplementedError")
+class UnimplementedError(OpError):
+    """Raised when an operation has not been implemented.
+
+    Some operations may raise this error when passed otherwise-valid
+    arguments that it does not currently support. For example, running
+    the @{tf.nn.max_pool} operation
+    would raise this error if pooling was requested on the batch dimension,
+    because this is not yet supported.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message):
+        """Creates an `UnimplementedError`."""
+        super().__init__(node_def, op, message, UNIMPLEMENTED)
+
+
+# @tf_export("errors.InternalError")
+class InternalError(OpError):
+    """Raised when the system experiences an internal error.
+
+    This exception is raised when some invariant expected by the runtime
+    has been broken. Catching this exception is not recommended.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message):
+        """Creates an `InternalError`."""
+        super().__init__(node_def, op, message, INTERNAL)
+
+
+# @tf_export("errors.UnavailableError")
+class UnavailableError(OpError):
+    """Raised when the runtime is currently unavailable.
+
+    This exception is not currently used.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message):
+        """Creates an `UnavailableError`."""
+        super().__init__(node_def, op, message, UNAVAILABLE)
+
+
+# @tf_export("errors.DataLossError")
+class DataLossError(OpError):
+    """Raised when unrecoverable data loss or corruption is encountered.
+
+    For example, this may be raised by running a
+    @{tf.WholeFileReader.read}
+    operation, if the file is truncated while it is being read.
+
+    @@__init__
+    """
+
+    def __init__(self, node_def, op, message):
+        """Creates a `DataLossError`."""
+        super().__init__(node_def, op, message, DATA_LOSS)
+
+
+_CODE_TO_EXCEPTION_CLASS = {
+    CANCELLED: CancelledError,
+    UNKNOWN: UnknownError,
+    INVALID_ARGUMENT: InvalidArgumentError,
+    DEADLINE_EXCEEDED: DeadlineExceededError,
+    NOT_FOUND: NotFoundError,
+    ALREADY_EXISTS: AlreadyExistsError,
+    PERMISSION_DENIED: PermissionDeniedError,
+    UNAUTHENTICATED: UnauthenticatedError,
+    RESOURCE_EXHAUSTED: ResourceExhaustedError,
+    FAILED_PRECONDITION: FailedPreconditionError,
+    ABORTED: AbortedError,
+    OUT_OF_RANGE: OutOfRangeError,
+    UNIMPLEMENTED: UnimplementedError,
+    INTERNAL: InternalError,
+    UNAVAILABLE: UnavailableError,
+    DATA_LOSS: DataLossError,
+}
+
+_EXCEPTION_CLASS_TO_CODE = dict(
+    ((class_, code) for (code, class_) in _CODE_TO_EXCEPTION_CLASS.items())
+)
+
+
+# @tf_export("errors.exception_type_from_error_code")
+def exception_type_from_error_code(error_code):
+    return _CODE_TO_EXCEPTION_CLASS[error_code]
+
+
+# @tf_export("errors.error_code_from_exception_type")
+def error_code_from_exception_type(cls):
+    return _EXCEPTION_CLASS_TO_CODE[cls]
+
+
+def _make_specific_exception(node_def, op, message, error_code):
+    try:
+        exc_type = exception_type_from_error_code(error_code)
+        return exc_type(node_def, op, message)
+    except KeyError:
+        warnings.warn("Unknown error code: %d" % error_code)
+        return UnknownError(node_def, op, message, error_code)
+
+
+# Named like a function for backwards compatibility with the
+# @tf_contextlib.contextmanager version, which was switched to a class to avoid
+# some object creation overhead.
+# TODO(b/77295559): expand use of TF_Status* SWIG typemap and deprecate this.
+# @tf_export("errors.raise_exception_on_not_ok_status")  # pylint: disable=invalid-name
+class raise_exception_on_not_ok_status:
+    """Context manager to check for C API status."""
+
+    def __enter__(self):
+        return "Status not OK"
+
+    def __exit__(self, type_arg, value_arg, traceback_arg):
+        return False  # False values do not suppress exceptions