Update deprecated Status symbols to use absl::Status.

PiperOrigin-RevId: 739963031

Author: cantonios

tensorflow_text/core/kernels/sentencepiece_kernels.cc

@@ -67,7 +67,7 @@ struct SentencepieceResource : public ResourceBase {
            (reverse == this->reverse);
   }
 
-  Status AsGraphDef(GraphDefBuilder* builder, Node** out) const override {
+  sentencepiece::util::Status AsGraphDef(GraphDefBuilder* builder, Node** out) const override {
     absl::ReaderMutexLock l(&mu);
     // We set use_node_name_sharing with a unique node name so that the resource
     // can outlive the kernel. This means that the lifetime of the re-created
@@ -93,10 +93,10 @@ struct SentencepieceResource : public ResourceBase {
 // TODO(broken) Determine a medium cost of a call to the SentencePiece processor
 constexpr int64 kCostPerUnit = 10000;
 
-::tensorflow::Status ToTFStatus(const sentencepiece::util::Status& s) {
-  if (s.ok()) return ::tensorflow::Status();
-  return ::tensorflow::Status(static_cast<::tensorflow::errors::Code>(s.code()),
-                              ::tensorflow::string(s.message()));
+absl::Status ToTFStatus(const sentencepiece::util::Status& s) {
+  if (s.ok()) return sentencepiece::util::Status();
+  return sentencepiece::util::Status(static_cast<absl::StatusCode>(s.code()),
+                      ::tensorflow::string(s.message()));
 }
 
 template <typename T>
@@ -114,8 +114,8 @@ int32 GetPieceOrId<int32>(
   return sp.id();
 }
 
-tensorflow::Status HandleExtraOptions(OpKernelContext* ctx,
-                                      SentencepieceResource* sp) {
+absl::Status HandleExtraOptions(OpKernelContext* ctx,
+                                SentencepieceResource* sp) {
   const Tensor* add_bos_tensor = nullptr;
   TF_RETURN_IF_ERROR(ctx->input("add_bos", &add_bos_tensor));
   const bool add_bos = add_bos_tensor->scalar<bool>()();
@@ -209,7 +209,7 @@ class SentencepieceOp : public OpKernel {
                   GetNodeAttr(this->def(), "model", &model_proto_attr));
 
               if (TF_PREDICT_FALSE(model_proto_attr.empty())) {
-                return Status(tensorflow::errors::InvalidArgument(
+                return sentencepiece::util::Status(tensorflow::errors::InvalidArgument(
                     "Model argument must be specified."));
               }
               // Loads serialized sentencepiece model proto to enable embedding

tensorflow_text/core/kernels/split_merge_tokenize_kernel.cc

@@ -64,24 +64,24 @@ bool IsBreakChar(absl::string_view text) {
   return u_isUWhiteSpace(c);
 }
 
-Status TokenizeByLabel(const absl::string_view& text,
-                       const Tensor& labels_tensor,
-                       bool force_split_at_break_character,
-                       std::vector<std::string>* tokens,
-                       std::vector<int>* begin_offset,
-                       std::vector<int>* end_offset, int* num_tokens) {
+absl::Status TokenizeByLabel(const absl::string_view& text,
+                             const Tensor& labels_tensor,
+                             bool force_split_at_break_character,
+                             std::vector<std::string>* tokens,
+                             std::vector<int>* begin_offset,
+                             std::vector<int>* end_offset, int* num_tokens) {
   std::vector<absl::string_view> chars;
   if (!GetUTF8Chars(text, &chars)) {
-    return Status(static_cast<tensorflow::errors::Code>(
-                      absl::StatusCode::kInvalidArgument),
-                  absl::StrCat("Input string is not utf8 valid: ", text));
+    return absl::Status(
+        static_cast<absl::StatusCode>(absl::StatusCode::kInvalidArgument),
+        absl::StrCat("Input string is not utf8 valid: ", text));
   }
 
   if (chars.size() > labels_tensor.dim_size(0)) {
-    return Status(static_cast<tensorflow::errors::Code>(
-                      absl::StatusCode::kInvalidArgument),
-                  absl::StrCat("Number of labels ", labels_tensor.dim_size(0),
-                               " is insufficient for text ", text));
+    return absl::Status(
+        static_cast<absl::StatusCode>(absl::StatusCode::kInvalidArgument),
+        absl::StrCat("Number of labels ", labels_tensor.dim_size(0),
+                     " is insufficient for text ", text));
   }
 
   const int split_label = 0;

tensorflow_text/core/kernels/tokenizer_from_logits_kernel.cc

@@ -68,22 +68,22 @@ bool IsBreakChar(absl::string_view text) {
 // allows us to retrieve the corresponding data from logits.  I.e., the logits
 // for the i-th character from text are logits(batch_index, i, 0) (for the
 // "split" action) and logits(batch_index, i, 1) (for the "merge" action).
-Status TokenizeByLogits(const absl::string_view& text,
-                        const TTypes<const float, 3>::Tensor& logits,
-                        int batch_index,
-                        bool force_split_at_break_character,
-                        std::vector<std::string>* tokens,
-                        std::vector<int>* begin_offset,
-                        std::vector<int>* end_offset, int* num_tokens) {
+absl::Status TokenizeByLogits(const absl::string_view& text,
+                              const TTypes<const float, 3>::Tensor& logits,
+                              int batch_index,
+                              bool force_split_at_break_character,
+                              std::vector<std::string>* tokens,
+                              std::vector<int>* begin_offset,
+                              std::vector<int>* end_offset, int* num_tokens) {
   std::vector<absl::string_view> chars;
   if (!GetUTF8Chars(text, &chars)) {
-    return Status(
+    return absl::Status(
         static_cast<absl::StatusCode>(absl::StatusCode::kInvalidArgument),
         absl::StrCat("Input string is not utf8 valid: ", text));
   }
 
   if (chars.size() > logits.dimension(1)) {
-    return Status(
+    return absl::Status(
         static_cast<absl::StatusCode>(absl::StatusCode::kInvalidArgument),
         absl::StrCat("Number of logits, ", logits.dimension(1),
                      ", is insufficient for text \"", text, "\""));

tensorflow_text/core/kernels/wordpiece_kernel.cc

@@ -82,8 +82,8 @@ bool GetSplitUnknownCharacters(OpKernelConstruction* ctx) {
   return split_unknown_characters;
 }
 
-Status GetTableHandle(const string& input_name, OpKernelContext* ctx,
-                      string* container, string* table_handle) {
+absl::Status GetTableHandle(const string& input_name, OpKernelContext* ctx,
+                            string* container, string* table_handle) {
   {
     mutex* mu;
     TF_RETURN_IF_ERROR(ctx->input_ref_mutex(input_name, &mu));
@@ -105,8 +105,8 @@ Status GetTableHandle(const string& input_name, OpKernelContext* ctx,
 // Gets the LookupTable stored in the ctx->resource_manager() with key
 // passed by attribute with name input_name, returns null if the table
 // doesn't exist.
-Status GetLookupTable(const string& input_name, OpKernelContext* ctx,
-                      lookup::LookupInterface** table) {
+absl::Status GetLookupTable(const string& input_name, OpKernelContext* ctx,
+                            lookup::LookupInterface** table) {
   string container;
   string table_handle;
   DataType handle_dtype;
@@ -135,7 +135,7 @@ class LookupTableVocab : public WordpieceVocab {
   Tensor default_value_;
 };
 
-Status ToStatus(const LookupStatus& status) {
+absl::Status ToStatus(const LookupStatus& status) {
   if (status.success) {
     return absl::OkStatus();
   }