
def 						UpperCAmelCase      (     a_		,       a_						)		->     List[Any]:







				"""simple docstring"""



				print("\nThe shortest path matrix using Floyd Warshall algorithm\n"						)
				for i in range(a_						):
								for j in range(a_						):
												if dist[i][j] != float("inf"						):
																print(int(dist[i][j]						)		,       end="\t"						)
												else:
																print("INF"		,       end="\t"						)
								print()


def 						UpperCAmelCase      (     a_		,       a_						)		->     int:







				"""simple docstring"""



				__A             =			[[float("inf"						) for _ in range(a_						)] for _ in range(a_						)]

				for i in range(a_						):
								for j in range(a_						):
												__A             =			graph[i][j]

												# check vertex k against all other vertices (i, j)
				for k in range(a_						):
								# looping through rows of graph array
								for i in range(a_						):
												# looping through columns of graph array
												for j in range(a_						):
																if (
																    dist[i][k] != float("inf"						)
																    and dist[k][j] != float("inf"						)
																    and dist[i][k] + dist[k][j] < dist[i][j]
																):
																				__A             =			dist[i][k] + dist[k][j]

				_print_dist(a_		,       a_						)
				return dist, v


if __name__ == "__main__":
					SCREAMING_SNAKE_CASE							:Any										=    int(input('Enter number of vertices: '))
					SCREAMING_SNAKE_CASE							:str										=    int(input('Enter number of edges: '))

					SCREAMING_SNAKE_CASE							:Tuple										=    [[float('inf') for i in range(v)] for j in range(v)]

					for i in range(v):
										SCREAMING_SNAKE_CASE							:str										=    0.0

										# src and dst are indices that must be within the array size graph[e][v]
										# failure to follow this will result in an error
					for i in range(e):
										print('\nEdge ', i + 1)
										SCREAMING_SNAKE_CASE							:Any										=    int(input('Enter source:'))
										SCREAMING_SNAKE_CASE							:str										=    int(input('Enter destination:'))
										SCREAMING_SNAKE_CASE							:int										=    float(input('Enter weight:'))
										SCREAMING_SNAKE_CASE							:int										=    weight

					floyd_warshall(graph, v)

					# Example Input
					# Enter number of vertices: 3
					# Enter number of edges: 2

					# # generated graph from vertex and edge inputs
					# [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
					# [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]

					# specify source, destination and weight for edge #1
					# Edge  1
					# Enter source:1
					# Enter destination:2
					# Enter weight:2

					# specify source, destination and weight for edge #2
					# Edge  2
					# Enter source:2
					# Enter destination:1
					# Enter weight:1

					# # Expected Output from the vertice, edge and src, dst, weight inputs!!
					# 0		INF	INF
					# INF	0	2
					# INF	1	0


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




	'''simple docstring'''





	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     UpperCamelCase_  (	self :			str			):
					super().setup()
					__A             =			self.model.config
					__A             =			-1
					for idx, label in config.idalabel.items():
									if label.lower().startswith("entail"			):
													__A             =			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     UpperCamelCase_  (	self :			int							,A :			Optional[Any]							,A :			Dict			):
					__A             =			labels
					return self.pre_processor(
					    [text] * len(A			)							,[f'''This example is {label}''' for label in labels]							,return_tensors="pt"							,padding="max_length"							,)







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