
"""simple docstring"""





import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    Pipeline,
    ZeroShotClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
UpperCamelCase_					:						Optional[Any]				= {'''LayoutLMv2Config''', '''LayoutLMv3Config'''}



@is_pipeline_test
class __lowerCAmelCase				(					unittest.TestCase   ):




			"""simple docstring"""







			snake_case	      =				MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
			snake_case	      =				TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

			if model_mapping is not None:
						snake_case	      =				{config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
			if tf_model_mapping is not None:
						snake_case	      =				{
						    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
						}




			def      lowerCamelCase__     (				self						:					Optional[int]       ,   _snake_case						:					Any       ,   _snake_case						:					Any       ,   _snake_case						:					Union[str, Any]	)      -> Optional[int]:







								"""simple docstring"""
								A_				 =						ZeroShotClassificationPipeline(
								    model=_snake_case       ,   tokenizer=_snake_case       ,   candidate_labels=["polics", "health"]	)
								return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]




			def      lowerCamelCase__     (				self						:					Dict       ,   _snake_case						:					List[Any]       ,   _snake_case						:					int	)      -> List[Any]:







								"""simple docstring"""
								A_				 =						classifier("Who are you voting for in 2020?"       ,   candidate_labels="politics"	)
								self.assertEqual(_snake_case       ,   {"sequence": ANY(_snake_case	), "labels": [ANY(_snake_case	)], "scores": [ANY(_snake_case	)]}	)

								# No kwarg
								A_				 =						classifier("Who are you voting for in 2020?"       ,   ["politics"]	)
								self.assertEqual(_snake_case       ,   {"sequence": ANY(_snake_case	), "labels": [ANY(_snake_case	)], "scores": [ANY(_snake_case	)]}	)

								A_				 =						classifier("Who are you voting for in 2020?"       ,   candidate_labels=["politics"]	)
								self.assertEqual(_snake_case       ,   {"sequence": ANY(_snake_case	), "labels": [ANY(_snake_case	)], "scores": [ANY(_snake_case	)]}	)

								A_				 =						classifier("Who are you voting for in 2020?"       ,   candidate_labels="politics, public health"	)
								self.assertEqual(
								    _snake_case       ,   {"sequence": ANY(_snake_case	), "labels": [ANY(_snake_case	), ANY(_snake_case	)], "scores": [ANY(_snake_case	), ANY(_snake_case	)]}	)
								self.assertAlmostEqual(sum(nested_simplify(outputs["scores"]	)	)       ,   1.0	)

								A_				 =						classifier("Who are you voting for in 2020?"       ,   candidate_labels=["politics", "public health"]	)
								self.assertEqual(
								    _snake_case       ,   {"sequence": ANY(_snake_case	), "labels": [ANY(_snake_case	), ANY(_snake_case	)], "scores": [ANY(_snake_case	), ANY(_snake_case	)]}	)
								self.assertAlmostEqual(sum(nested_simplify(outputs["scores"]	)	)       ,   1.0	)

								A_				 =						classifier(
								    "Who are you voting for in 2020?"       ,   candidate_labels="politics"       ,   hypothesis_template="This text is about {}"	)
								self.assertEqual(_snake_case       ,   {"sequence": ANY(_snake_case	), "labels": [ANY(_snake_case	)], "scores": [ANY(_snake_case	)]}	)

								# https://github.com/huggingface/transformers/issues/13846
								A_				 =						classifier(["I am happy"]       ,   ["positive", "negative"]	)
								self.assertEqual(
								    _snake_case       ,   [
								        {"sequence": ANY(_snake_case	), "labels": [ANY(_snake_case	), ANY(_snake_case	)], "scores": [ANY(_snake_case	), ANY(_snake_case	)]}
								        for i in range(1	)
								    ]       ,   )
								A_				 =						classifier(["I am happy", "I am sad"]       ,   ["positive", "negative"]	)
								self.assertEqual(
								    _snake_case       ,   [
								        {"sequence": ANY(_snake_case	), "labels": [ANY(_snake_case	), ANY(_snake_case	)], "scores": [ANY(_snake_case	), ANY(_snake_case	)]}
								        for i in range(2	)
								    ]       ,   )

								with self.assertRaises(_snake_case	):
													classifier(""       ,   candidate_labels="politics"	)

								with self.assertRaises(_snake_case	):
													classifier(_snake_case       ,   candidate_labels="politics"	)

								with self.assertRaises(_snake_case	):
													classifier("Who are you voting for in 2020?"       ,   candidate_labels=""	)

								with self.assertRaises(_snake_case	):
													classifier("Who are you voting for in 2020?"       ,   candidate_labels=_snake_case	)

								with self.assertRaises(_snake_case	):
													classifier(
													    "Who are you voting for in 2020?"       ,   candidate_labels="politics"       ,   hypothesis_template="Not formatting template"       ,   )

								with self.assertRaises(_snake_case	):
													classifier(
													    "Who are you voting for in 2020?"       ,   candidate_labels="politics"       ,   hypothesis_template=_snake_case       ,   )

								self.run_entailment_id(_snake_case	)




			def      lowerCamelCase__     (				self						:					List[Any]       ,   _snake_case						:					Pipeline	)      -> Dict:







								"""simple docstring"""
								A_				 =						zero_shot_classifier.model.config
								A_				 =						config.labelaid
								A_				 =						zero_shot_classifier.entailment_id

								A_				 =						{"LABEL_0": 0, "LABEL_1": 1, "LABEL_2": 2}
								self.assertEqual(zero_shot_classifier.entailment_id       ,   -1	)

								A_				 =						{"entailment": 0, "neutral": 1, "contradiction": 2}
								self.assertEqual(zero_shot_classifier.entailment_id       ,   0	)

								A_				 =						{"ENTAIL": 0, "NON-ENTAIL": 1}
								self.assertEqual(zero_shot_classifier.entailment_id       ,   0	)

								A_				 =						{"ENTAIL": 2, "NEUTRAL": 1, "CONTR": 0}
								self.assertEqual(zero_shot_classifier.entailment_id       ,   2	)

								A_				 =						original_labelaid
								self.assertEqual(_snake_case       ,   zero_shot_classifier.entailment_id	)




			@require_torch
			def      lowerCamelCase__     (				self						:					List[Any]	)      -> Tuple:







								"""simple docstring"""
								A_				 =						pipeline(
								    "zero-shot-classification"       ,   model="sshleifer/tiny-distilbert-base-cased-distilled-squad"       ,   framework="pt"       ,   )
								# There was a regression in 4.10 for this
								# Adding a test so we don't make the mistake again.
								# https://github.com/huggingface/transformers/issues/13381#issuecomment-912343499
								zero_shot_classifier(
								    "Who are you voting for in 2020?" * 100       ,   candidate_labels=["politics", "public health", "science"]	)




			@require_torch
			def      lowerCamelCase__     (				self						:					Optional[Any]	)      -> str:







								"""simple docstring"""
								A_				 =						pipeline(
								    "zero-shot-classification"       ,   model="sshleifer/tiny-distilbert-base-cased-distilled-squad"       ,   framework="pt"       ,   )
								A_				 =						zero_shot_classifier(
								    "Who are you voting for in 2020?"       ,   candidate_labels=["politics", "public health", "science"]	)

								self.assertEqual(
								    nested_simplify(_snake_case	)       ,   {
								        "sequence": "Who are you voting for in 2020?",
								        "labels": ["science", "public health", "politics"],
								        "scores": [0.3_3_3, 0.3_3_3, 0.3_3_3],
								    }       ,   )




			@require_tf
			def      lowerCamelCase__     (				self						:					Any	)      -> List[Any]:







								"""simple docstring"""
								A_				 =						pipeline(
								    "zero-shot-classification"       ,   model="sshleifer/tiny-distilbert-base-cased-distilled-squad"       ,   framework="tf"       ,   )
								A_				 =						zero_shot_classifier(
								    "Who are you voting for in 2020?"       ,   candidate_labels=["politics", "public health", "science"]	)

								self.assertEqual(
								    nested_simplify(_snake_case	)       ,   {
								        "sequence": "Who are you voting for in 2020?",
								        "labels": ["science", "public health", "politics"],
								        "scores": [0.3_3_3, 0.3_3_3, 0.3_3_3],
								    }       ,   )




			@slow
			@require_torch
			def      lowerCamelCase__     (				self						:					Union[str, Any]	)      -> Optional[int]:







								"""simple docstring"""
								A_				 =						pipeline("zero-shot-classification"       ,   model="roberta-large-mnli"       ,   framework="pt"	)
								A_				 =						zero_shot_classifier(
								    "Who are you voting for in 2020?"       ,   candidate_labels=["politics", "public health", "science"]	)

								self.assertEqual(
								    nested_simplify(_snake_case	)       ,   {
								        "sequence": "Who are you voting for in 2020?",
								        "labels": ["politics", "public health", "science"],
								        "scores": [0.9_7_6, 0.0_1_5, 0.0_0_9],
								    }       ,   )
								A_				 =						zero_shot_classifier(
								    "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks"
								    " in an encoder-decoder configuration. The best performing models also connect the encoder and decoder"
								    " through an attention mechanism. We propose a new simple network architecture, the Transformer, based"
								    " solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two"
								    " machine translation tasks show these models to be superior in quality while being more parallelizable"
								    " and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014"
								    " English-to-German translation task, improving over the existing best results, including ensembles by"
								    " over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new"
								    " single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small"
								    " fraction of the training costs of the best models from the literature. We show that the Transformer"
								    " generalizes well to other tasks by applying it successfully to English constituency parsing both with"
								    " large and limited training data."       ,   candidate_labels=["machine learning", "statistics", "translation", "vision"]       ,   multi_label=_snake_case       ,   )
								self.assertEqual(
								    nested_simplify(_snake_case	)       ,   {
								        "sequence": (
								            "The dominant sequence transduction models are based on complex recurrent or convolutional neural"
								            " networks in an encoder-decoder configuration. The best performing models also connect the"
								            " encoder and decoder through an attention mechanism. We propose a new simple network"
								            " architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence"
								            " and convolutions entirely. Experiments on two machine translation tasks show these models to be"
								            " superior in quality while being more parallelizable and requiring significantly less time to"
								            " train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,"
								            " improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014"
								            " English-to-French translation task, our model establishes a new single-model state-of-the-art"
								            " BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training"
								            " costs of the best models from the literature. We show that the Transformer generalizes well to"
								            " other tasks by applying it successfully to English constituency parsing both with large and"
								            " limited training data."
								        ),
								        "labels": ["translation", "machine learning", "vision", "statistics"],
								        "scores": [0.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
								    }       ,   )






			@slow
			@require_tf
			def      lowerCamelCase__     (				self						:					Any	)      -> int:







								"""simple docstring"""
								A_				 =						pipeline("zero-shot-classification"       ,   model="roberta-large-mnli"       ,   framework="tf"	)
								A_				 =						zero_shot_classifier(
								    "Who are you voting for in 2020?"       ,   candidate_labels=["politics", "public health", "science"]	)

								self.assertEqual(
								    nested_simplify(_snake_case	)       ,   {
								        "sequence": "Who are you voting for in 2020?",
								        "labels": ["politics", "public health", "science"],
								        "scores": [0.9_7_6, 0.0_1_5, 0.0_0_9],
								    }       ,   )
								A_				 =						zero_shot_classifier(
								    "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks"
								    " in an encoder-decoder configuration. The best performing models also connect the encoder and decoder"
								    " through an attention mechanism. We propose a new simple network architecture, the Transformer, based"
								    " solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two"
								    " machine translation tasks show these models to be superior in quality while being more parallelizable"
								    " and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014"
								    " English-to-German translation task, improving over the existing best results, including ensembles by"
								    " over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new"
								    " single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small"
								    " fraction of the training costs of the best models from the literature. We show that the Transformer"
								    " generalizes well to other tasks by applying it successfully to English constituency parsing both with"
								    " large and limited training data."       ,   candidate_labels=["machine learning", "statistics", "translation", "vision"]       ,   multi_label=_snake_case       ,   )
								self.assertEqual(
								    nested_simplify(_snake_case	)       ,   {
								        "sequence": (
								            "The dominant sequence transduction models are based on complex recurrent or convolutional neural"
								            " networks in an encoder-decoder configuration. The best performing models also connect the"
								            " encoder and decoder through an attention mechanism. We propose a new simple network"
								            " architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence"
								            " and convolutions entirely. Experiments on two machine translation tasks show these models to be"
								            " superior in quality while being more parallelizable and requiring significantly less time to"
								            " train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,"
								            " improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014"
								            " English-to-French translation task, our model establishes a new single-model state-of-the-art"
								            " BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training"
								            " costs of the best models from the literature. We show that the Transformer generalizes well to"
								            " other tasks by applying it successfully to English constituency parsing both with large and"
								            " limited training data."
								        ),
								        "labels": ["translation", "machine learning", "vision", "statistics"],
								        "scores": [0.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
								    }       ,   )






"""simple docstring"""





from math import atan, cos, radians, sin, tan

from .haversine_distance import haversine_distance

UpperCamelCase_					:						Tuple				= 637_8137.0
UpperCamelCase_					:						List[str]				= 635_6752.31_4245
UpperCamelCase_					:						Dict				= 637_8137
def 							A_     (__a				,   __a				,   __a				,   __a				):

					'''simple docstring'''





					A_				 =						(AXIS_A - AXIS_B) / AXIS_A
					# Parametric latitudes
					# https://en.wikipedia.org/wiki/Latitude#Parametric_(or_reduced)_latitude
					A_				 =						atan((1 - flattening) * tan(radians(__a				)				)				)
					A_				 =						atan((1 - flattening) * tan(radians(__a				)				)				)

					# Compute central angle between two points
					# using haversine theta. sigma =  haversine_distance / equatorial radius
					A_				 =						haversine_distance(__a				,   __a				,   __a				,   __a				) / EQUATORIAL_RADIUS

					# Intermediate P and Q values
					A_				 =						(b_lata + b_lata) / 2
					A_				 =						(b_lata - b_lata) / 2

					# Intermediate X value
					# X = (sigma - sin(sigma)) * sin^2Pcos^2Q / cos^2(sigma/2)
					A_				 =						(sin(__a				) ** 2) * (cos(__a				) ** 2)
					A_				 =						cos(sigma / 2				) ** 2
					A_				 =						(sigma - sin(__a				)) * (x_numerator / x_demonimator)

					# Intermediate Y value
					# Y = (sigma + sin(sigma)) * cos^2Psin^2Q / sin^2(sigma/2)
					A_				 =						(cos(__a				) ** 2) * (sin(__a				) ** 2)
					A_				 =						sin(sigma / 2				) ** 2
					A_				 =						(sigma + sin(__a				)) * (y_numerator / y_denominator)

					return EQUATORIAL_RADIUS * (sigma - ((flattening / 2) * (x_value + y_value)))


if __name__ == "__main__":
		import doctest

		doctest.testmod()




