



# Copyright 2023 The HuggingFace Inc. team. 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.
import torch

from ..models.auto import AutoModelForSequenceClassification, AutoTokenizer
from .base import PipelineTool



class     lowerCAmelCase_		(  a__							):
       UpperCAmelCase__    : List[Any]       					=  "facebook/bart-large-mnli"
       UpperCAmelCase__    : Dict       					=  (
           "This is a tool that classifies an English text using provided labels. It takes two inputs: `text`, which "
           "should be the text to classify, and `labels`, which should be the list of labels to use for classification. "
           "It returns the most likely label in the list of provided `labels` for the input text."
       )
       UpperCAmelCase__    : Union[str, Any]       					=  "text_classifier"
       UpperCAmelCase__    : List[Any]       					=  AutoTokenizer
       UpperCAmelCase__    : List[Any]       					=  AutoModelForSequenceClassification

       UpperCAmelCase__    : Any       					=  ["text", ["text"]]
       UpperCAmelCase__    : List[str]       					=  ["text"]
       def  snake_case_	(      self	)					->		Any:
          super().setup()
          UpperCamelCase   :  Any						     =     self.model.config
          UpperCamelCase   :  Dict						     =     -1
          for idx, label in config.idalabel.items():
             if label.lower().startswith('entail'	):
                UpperCamelCase   :  Optional[Any]						     =     int(SCREAMING_SNAKE_CASE_	)
          if self.entailment_id == -1:
             raise ValueError('Could not determine the entailment ID from the model config, please pass it at init.'	)
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		str:
          UpperCamelCase   :  List[Any]						     =     labels
          return self.pre_processor(
              [text] * len(SCREAMING_SNAKE_CASE_	),      [F"""This example is {label}""" for label in labels],      return_tensors='pt',      padding='max_length',      )






       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_	)					->		Tuple:
          UpperCamelCase   :  Union[str, Any]						     =     outputs.logits
          UpperCamelCase   :  Optional[int]						     =     torch.argmax(logits[:, 2]	).item()
          return self._labels[label_id]








from typing import Optional

import pyspark

from .. import Features, NamedSplit
from ..download import DownloadMode
from ..packaged_modules.spark.spark import Spark
from .abc import AbstractDatasetReader



class     lowerCAmelCase_		(  a__							):
       def __init__(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_ = None,      SCREAMING_SNAKE_CASE_ = None,      SCREAMING_SNAKE_CASE_ = True,      SCREAMING_SNAKE_CASE_ = None,      SCREAMING_SNAKE_CASE_ = False,      SCREAMING_SNAKE_CASE_ = None,      SCREAMING_SNAKE_CASE_ = True,      SCREAMING_SNAKE_CASE_ = "arrow",      **SCREAMING_SNAKE_CASE_,      )					->		int:
          super().__init__(
              split=SCREAMING_SNAKE_CASE_,      features=SCREAMING_SNAKE_CASE_,      cache_dir=SCREAMING_SNAKE_CASE_,      keep_in_memory=SCREAMING_SNAKE_CASE_,      streaming=SCREAMING_SNAKE_CASE_,      **SCREAMING_SNAKE_CASE_,      )
          UpperCamelCase   :  Any						     =     load_from_cache_file
          UpperCamelCase   :  Any						     =     file_format
          UpperCamelCase   :  str						     =     Spark(
              df=SCREAMING_SNAKE_CASE_,      features=SCREAMING_SNAKE_CASE_,      cache_dir=SCREAMING_SNAKE_CASE_,      working_dir=SCREAMING_SNAKE_CASE_,      **SCREAMING_SNAKE_CASE_,      )






       def  snake_case_	(      self	)					->		Tuple:
          if self.streaming:
             return self.builder.as_streaming_dataset(split=self.split	)
          UpperCamelCase   :  Dict						     =     None if self._load_from_cache_file else DownloadMode.FORCE_REDOWNLOAD
          self.builder.download_and_prepare(
              download_mode=SCREAMING_SNAKE_CASE_,      file_format=self._file_format,      )
          return self.builder.as_dataset(split=self.split	)



