


# 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  snake_case_     (lowerCamelCase_   ):
					UpperCAmelCase__      :					Tuple					   =    '''facebook/bart-large-mnli'''
					UpperCAmelCase__      :					Optional[Any]					   =    (
					    '''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__      :					List[str]					   =    '''text_classifier'''
					UpperCAmelCase__      :					List[str]					   =    AutoTokenizer
					UpperCAmelCase__      :					Union[str, Any]					   =    AutoModelForSequenceClassification

					UpperCAmelCase__      :					int					   =    ['''text''', ['''text''']]
					UpperCAmelCase__      :					Dict					   =    ['''text''']
					def 				lowerCamelCase__(   self     :List[str]   )      ->					int:
												super().setup()
												a__    =  self.model.config
												a__    =  -1
												for idx, label in config.idalabel.items():
																			if label.lower().startswith('entail'   ):
																										a__    =  int(__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 				lowerCamelCase__(   self     :Union[str, Any]    ,__snake_case     :List[str]    ,__snake_case     :Dict   )      ->					int:
												a__    =  labels
												return self.pre_processor(
												    [text] * len(__snake_case   )    ,[F'This example is {label}' for label in labels]    ,return_tensors='pt'    ,padding='max_length'    ,)



					def 				lowerCamelCase__(   self     :Dict    ,__snake_case     :List[Any]   )      ->					Union[str, Any]:
												a__    =  outputs.logits
												a__    =  torch.argmax(logits[:, 2]   ).item()
												return self._labels[label_id]








from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


snake_case							: Optional[Any]      =   {'''configuration_focalnet''': ['''FOCALNET_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''FocalNetConfig''']}


try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						snake_case							: Optional[int]      =   [
						    '''FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''FocalNetForImageClassification''',
						    '''FocalNetForMaskedImageModeling''',
						    '''FocalNetBackbone''',
						    '''FocalNetModel''',
						    '''FocalNetPreTrainedModel''',
						]

if TYPE_CHECKING:
						from .configuration_focalnet import FOCALNET_PRETRAINED_CONFIG_ARCHIVE_MAP, FocalNetConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_focalnet import (
												    FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST,
												    FocalNetBackbone,
												    FocalNetForImageClassification,
												    FocalNetForMaskedImageModeling,
												    FocalNetModel,
												    FocalNetPreTrainedModel,
												)

else:
						import sys

						snake_case							: Union[str, Any]      =   _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




