


# 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 (							lowercase__):


       """simple docstring"""




       A__											=			"facebook/bart-large-mnli"
       A__											=			(
           "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."
       )
       A__											=			"text_classifier"
       A__											=			AutoTokenizer
       A__											=			AutoModelForSequenceClassification

       A__											=			["text", ["text"]]
       A__											=			["text"]





       def 						lowerCAmelCase     (   self							:			str       ):


             '''simple docstring'''



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


             '''simple docstring'''



             lowerCamelCase__		:				Tuple    =  labels
             return self.pre_processor(
                 [text] * len(__lowerCamelCase       )					,      [f"This example is {label}" for label in labels]					,      return_tensors="pt"					,      padding="max_length"					,      )





       def 						lowerCAmelCase     (   self							:			Any					,      __lowerCamelCase							:			List[Any]       ):


             '''simple docstring'''



             lowerCamelCase__		:				Tuple    =  outputs.logits
             lowerCamelCase__		:				Union[str, Any]    =  torch.argmax(logits[:, 2]       ).item()
             return self._labels[label_id]






class 			_lowercase :  # Public class to implement a graph


       """simple docstring"""




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


             '''simple docstring'''



             lowerCamelCase__		:				int    =  row
             lowerCamelCase__		:				Optional[Any]    =  col
             lowerCamelCase__		:				Union[str, Any]    =  graph





       def 						lowerCAmelCase     (   self							:			Optional[int]					,      __lowerCamelCase							:			int					,      __lowerCamelCase							:			int					,      __lowerCamelCase							:			list[list[bool]]       ):


             '''simple docstring'''



             return (
                 0 <= i < self.ROW
                 and 0 <= j < self.COL
                 and not visited[i][j]
                 and self.graph[i][j]
             )





       def 						lowerCAmelCase     (   self							:			Dict					,      __lowerCamelCase							:			int					,      __lowerCamelCase							:			int					,      __lowerCamelCase							:			list[list[bool]]       ):


             '''simple docstring'''



             lowerCamelCase__		:				str    =  [-1, -1, -1, 0, 0, 1, 1, 1]  # Coordinate order
             lowerCamelCase__		:				Tuple    =  [-1, 0, 1, -1, 1, -1, 0, 1]
             lowerCamelCase__		:				List[Any]    =  True  # Make those cells visited
             for k in range(8       ):
                   if self.is_safe(i + row_nbr[k]					,      j + col_nbr[k]					,      __lowerCamelCase       ):
                         self.diffs(i + row_nbr[k]					,      j + col_nbr[k]					,      __lowerCamelCase       )





       def 						lowerCAmelCase     (   self							:			List[Any]       ):  # And finally, count all islands.


             '''simple docstring'''



             lowerCamelCase__		:				List[Any]    =  [[False for j in range(self.COL       )] for i in range(self.ROW       )]
             lowerCamelCase__		:				Optional[Any]    =  0
             for i in range(self.ROW       ):
                   for j in range(self.COL       ):
                         if visited[i][j] is False and self.graph[i][j] == 1:
                               self.diffs(__lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase       )
                               count += 1
             return count


