

"""simple docstring"""




# 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      __lowercase			(    __lowerCamelCase					):
  snake_case_				       =       """facebook/bart-large-mnli"""
  snake_case_				       =       (
      """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."""
  )
  snake_case_				       =       """text_classifier"""
  snake_case_				       =       AutoTokenizer
  snake_case_				       =       AutoModelForSequenceClassification

  snake_case_				       =       ["""text""", ["""text"""]]
  snake_case_				       =       ["""text"""]

  def    __lowercase       (  self		:			Optional[Any]    ):






   '''simple docstring'''
   super().setup()
   UpperCAmelCase__					:  Any					   =					self.model.config
   UpperCAmelCase__					:  Optional[int]					   =					-1
   for idx, label in config.idalabel.items():
    if label.lower().startswith("""entail"""    ):
     UpperCAmelCase__					:  Optional[Any]					   =					int(A    )
   if self.entailment_id == -1:
    raise ValueError("""Could not determine the entailment ID from the model config, please pass it at init."""    )

  def    __lowercase       (  self		:			str					,A		:			List[Any]					,A		:			List[str]    ):






   '''simple docstring'''
   UpperCAmelCase__					:  str					   =					labels
   return self.pre_processor(
       [text] * len(A    )					,[f"This example is {label}" for label in labels]					,return_tensors="""pt"""					,padding="""max_length"""					,)




  def    __lowercase       (  self		:			Tuple					,A		:			Union[str, Any]    ):






   '''simple docstring'''
   UpperCAmelCase__					:  int					   =					outputs.logits
   UpperCAmelCase__					:  Union[str, Any]					   =					torch.argmax(logits[:, 2]    ).item()
   return self._labels[label_id]








"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__UpperCAmelCase =				{
    'configuration_table_transformer': [
        'TABLE_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'TableTransformerConfig',
        'TableTransformerOnnxConfig',
    ]
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase =				[
          'TABLE_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
          'TableTransformerForObjectDetection',
          'TableTransformerModel',
          'TableTransformerPreTrainedModel',
      ]


if TYPE_CHECKING:
      from .configuration_table_transformer import (
          TABLE_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
          TableTransformerConfig,
          TableTransformerOnnxConfig,
      )

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_table_transformer import (
                TABLE_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
                TableTransformerForObjectDetection,
                TableTransformerModel,
                TableTransformerPreTrainedModel,
            )

else:
      import sys

      __UpperCAmelCase =				_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





