
# 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      A__							(     __magic_name__	):
				lowercase			    =  'facebook/bart-large-mnli'
				lowercase			    =  (
				    '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.'
				)
				lowercase			    =  'text_classifier'
				lowercase			    =  AutoTokenizer
				lowercase			    =  AutoModelForSequenceClassification

				lowercase			    =  ['text', ['text']]
				lowercase			    =  ['text']






				def 							_lowerCamelCase		(						self					:      Optional[int]   ):






							'''simple docstring'''







							super().setup()
							lowerCAmelCase__      :      Tuple         =		self.model.config
							lowerCAmelCase__      :      List[Any]         =		-1
							for idx, label in config.idalabel.items():
										if label.lower().startswith('entail'   ):
													lowerCAmelCase__      :      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 							_lowerCamelCase		(						self					:      Any    ,     a					:      Optional[int]    ,     a					:      Dict   ):






							'''simple docstring'''







							lowerCAmelCase__      :      List[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 							_lowerCamelCase		(						self					:      int    ,     a					:      str   ):






							'''simple docstring'''







							lowerCAmelCase__      :      Dict         =		outputs.logits
							lowerCAmelCase__      :      List[Any]         =		torch.argmax(logits[:, 2]   ).item()
							return self._labels[label_id]

class      A__							:






				def __init__(						self					:      Dict    ,     a					:      list[int]   ):






							'''simple docstring'''







							lowerCAmelCase__      :      Union[str, Any]         =		len(a   )
							lowerCAmelCase__      :      Optional[Any]         =		[0] * len_array

							if len_array > 0:
										lowerCAmelCase__      :      List[Any]         =		array[0]

							for i in range(1    ,     a   ):
										lowerCAmelCase__      :      Optional[int]         =		self.prefix_sum[i - 1] + array[i]






				def 							_lowerCamelCase		(						self					:      int    ,     a					:      int    ,     a					:      int   ):






							'''simple docstring'''







							if start == 0:
										return self.prefix_sum[end]

							return self.prefix_sum[end] - self.prefix_sum[start - 1]






				def 							_lowerCamelCase		(						self					:      Optional[Any]    ,     a					:      int   ):






							'''simple docstring'''







							lowerCAmelCase__      :      Any         =		{0}
							for sum_item in self.prefix_sum:
										if sum_item - target_sum in sums:
													return True

										sums.add(a   )

							return False


if __name__ == "__main__":
					import doctest

					doctest.testmod()