






"""simple docstring"""





import json
import os
import unittest

from transformers import DebertaTokenizer, DebertaTokenizerFast
from transformers.models.deberta.tokenization_deberta import VOCAB_FILES_NAMES
from transformers.testing_utils import slow

from ...test_tokenization_common import TokenizerTesterMixin


class      _lowercase (     lowerCAmelCase		,  unittest.TestCase						):
      _a   :     List[Any]								=   DebertaTokenizer
      _a   :     List[Any]								=   True
      _a   :     List[str]								=   DebertaTokenizerFast


      def _UpperCamelCase						(    self				:	Optional[Any]						):





            """simple docstring"""







            super().setUp()

            # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
            __snake_case      :    int  			=[
                "l",
                "o",
                "w",
                "e",
                "r",
                "s",
                "t",
                "i",
                "d",
                "n",
                "\u0120",
                "\u0120l",
                "\u0120n",
                "\u0120lo",
                "\u0120low",
                "er",
                "\u0120lowest",
                "\u0120newer",
                "\u0120wider",
                "[UNK]",
            ]
            __snake_case      :    str  			=dict(zip(__A							,   range(len(__A						)						)						)						)
            __snake_case      :    List[Any]  			=["#version: 0.2", "\u0120 l", "\u0120l o", "\u0120lo w", "e r", ""]
            __snake_case      :    List[Any]  			={"unk_token": "[UNK]"}

            __snake_case      :    List[Any]  			=os.path.join(self.tmpdirname							,   VOCAB_FILES_NAMES['''vocab_file''']						)
            __snake_case      :    Any  			=os.path.join(self.tmpdirname							,   VOCAB_FILES_NAMES['''merges_file''']						)
            with open(self.vocab_file							,   '''w'''							,   encoding='''utf-8'''						) as fp:
                  fp.write(json.dumps(__A						) + '''\n'''						)
            with open(self.merges_file							,   '''w'''							,   encoding='''utf-8'''						) as fp:
                  fp.write('''\n'''.join(__A						)						)


      def _UpperCamelCase						(    self				:	str							,   **a				:	Union[str, Any]						):





            """simple docstring"""







            kwargs.update(self.special_tokens_map						)
            return self.tokenizer_class.from_pretrained(self.tmpdirname							,   **__A						)


      def _UpperCamelCase						(    self				:	str							,   a				:	Optional[Any]						):





            """simple docstring"""







            __snake_case      :    Optional[Any]  			="lower newer"
            __snake_case      :    Any  			="lower newer"
            return input_text, output_text


      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            __snake_case      :    Any  			=self.get_tokenizer()
            __snake_case      :    Any  			="lower newer"
            __snake_case      :    Optional[Any]  			=["l", "o", "w", "er", "\u0120", "n", "e", "w", "er"]
            __snake_case      :    List[Any]  			=tokenizer.tokenize(__A						)
            self.assertListEqual(__A							,   __A						)

            __snake_case      :    Dict  			=tokens + [tokenizer.unk_token]
            __snake_case      :    List[Any]  			=[0, 1, 2, 1_5, 1_0, 9, 3, 2, 1_5, 1_9]
            self.assertListEqual(tokenizer.convert_tokens_to_ids(__A						)							,   __A						)


      def _UpperCamelCase						(    self				:	int						):





            """simple docstring"""







            __snake_case      :    Tuple  			=self.get_tokenizer()
            __snake_case      :    List[Any]  			=tokenizer('''Hello'''							,   '''World'''						)
            __snake_case      :    Union[str, Any]  			=[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]
            self.assertListEqual(tokd['''token_type_ids''']							,   __A						)


      @slow
      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            __snake_case      :    Optional[int]  			=self.tokenizer_class.from_pretrained('''microsoft/deberta-base'''						)

            __snake_case      :    int  			=tokenizer.encode('''sequence builders'''							,   add_special_tokens=__A						)
            __snake_case      :    int  			=tokenizer.encode('''multi-sequence build'''							,   add_special_tokens=__A						)

            __snake_case      :    Any  			=tokenizer.encode(
                '''sequence builders'''							,   add_special_tokens=__A							,   add_prefix_space=__A						)
            __snake_case      :    Optional[int]  			=tokenizer.encode(
                '''sequence builders'''							,   '''multi-sequence build'''							,   add_special_tokens=__A							,   add_prefix_space=__A						)

            __snake_case      :    str  			=tokenizer.build_inputs_with_special_tokens(__A						)
            __snake_case      :    Tuple  			=tokenizer.build_inputs_with_special_tokens(__A							,   __A						)

            assert encoded_sentence == encoded_text_from_decode
            assert encoded_pair == encoded_pair_from_decode







      @slow
      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            __snake_case      :    Optional[int]  			=[self.tokenizer_class]
            if self.test_rust_tokenizer:
                  tokenizer_classes.append(self.rust_tokenizer_class						)

            for tokenizer_class in tokenizer_classes:
                  __snake_case      :    List[str]  			=tokenizer_class.from_pretrained('''microsoft/deberta-base'''						)

                  __snake_case      :    str  			=[
                      "ALBERT: A Lite BERT for Self-supervised Learning of Language Representations",
                      "ALBERT incorporates two parameter reduction techniques",
                      "The first one is a factorized embedding parameterization. By decomposing the large vocabulary"
                      " embedding matrix into two small matrices, we separate the size of the hidden layers from the size of"
                      " vocabulary embedding.",
                  ]

                  __snake_case      :    Dict  			=tokenizer(__A							,   padding=__A						)
                  __snake_case      :    Optional[int]  			=[tokenizer.decode(__A							,   skip_special_tokens=__A						) for seq in encoding["input_ids"]]

                  # fmt: off
                  __snake_case      :    Tuple  			={
                      "input_ids": [
                          [1, 2_1_1_8, 1_1_1_2_6, 5_6_5, 3_5, 8_3, 2_5_1_9_1, 1_6_3, 1_8_8_5_4, 1_3, 1_2_1_5_6, 1_2, 1_6_1_0_1, 2_5_3_7_6, 1_3_8_0_7, 9, 2_2_2_0_5, 2_7_8_9_3, 1_6_3_5, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                          [1, 2_1_1_8, 1_1_1_2_6, 5_6_5, 2_4_5_3_6, 8_0, 4_3_7_9_7, 4_8_7_8, 7_3_7_3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                          [1, 1_3_3, 7_8, 6_5, 1_6, 1_0, 3_7_2_4, 1_5_3_8, 3_3_1_8_3, 1_1_3_0_3, 4_3_7_9_7, 1_9_3_8, 4, 8_7_0, 2_4_1_6_5, 2_9_1_0_5, 5, 7_3_9, 3_2_6_4_4, 3_3_1_8_3, 1_1_3_0_3, 3_6_1_7_3, 8_8, 8_0, 6_5_0, 7_8_2_1, 4_5_9_4_0, 6, 5_2, 2_5_5_9, 5, 1_8_3_6, 9, 5, 7_3_9_7, 1_3_1_7_1, 3_1, 5, 1_8_3_6, 9, 3_2_6_4_4, 3_3_1_8_3, 1_1_3_0_3, 4, 2]
                      ],
                      "token_type_ids": [
                          [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                          [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                          [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
                      ],
                      "attention_mask": [
                          [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                          [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                          [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
                      ]
                  }
                  # fmt: on

                  __snake_case      :    str  			=[
                      "ALBERT: A Lite BERT for Self-supervised Learning of Language Representations",
                      "ALBERT incorporates two parameter reduction techniques",
                      "The first one is a factorized embedding parameterization. By decomposing the large vocabulary"
                      " embedding matrix into two small matrices, we separate the size of the hidden layers from the size of"
                      " vocabulary embedding.",
                  ]

                  self.assertDictEqual(encoding.data							,   __A						)

                  for expected, decoded in zip(__A							,   __A						):
                        self.assertEqual(__A							,   __A						)












"""simple docstring"""





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

from .haversine_distance import haversine_distance

UpperCamelCase_	:				Optional[Any]										= 6_37_81_37.0
UpperCamelCase_	:				Optional[Any]										= 6_35_67_52.31_42_45
UpperCamelCase_	:				Union[str, Any]										= 6378137



def     __lowercase					(    a :				float       ,		a :				float       ,		a :				float       ,		a :				float )					->					float:
      __snake_case      :    Optional[Any]  			=(AXIS_A - AXIS_B) / AXIS_A
      # Parametric latitudes
      # https://en.wikipedia.org/wiki/Latitude#Parametric_(or_reduced)_latitude
      __snake_case      :    List[str]  			=atan((1 - flattening) * tan(radians(a ) ) )
      __snake_case      :    Any  			=atan((1 - flattening) * tan(radians(a ) ) )

      # Compute central angle between two points
      # using haversine theta. sigma =  haversine_distance / equatorial radius
      __snake_case      :    Optional[Any]  			=haversine_distance(a       ,		a       ,		a       ,		a ) / EQUATORIAL_RADIUS

      # Intermediate P and Q values
      __snake_case      :    List[str]  			=(b_lata + b_lata) / 2
      __snake_case      :    Dict  			=(b_lata - b_lata) / 2

      # Intermediate X value
      # X = (sigma - sin(sigma)) * sin^2Pcos^2Q / cos^2(sigma/2)
      __snake_case      :    Optional[int]  			=(sin(a ) ** 2) * (cos(a ) ** 2)
      __snake_case      :    Any  			=cos(sigma / 2 ) ** 2
      __snake_case      :    Optional[Any]  			=(sigma - sin(a )) * (x_numerator / x_demonimator)

      # Intermediate Y value
      # Y = (sigma + sin(sigma)) * cos^2Psin^2Q / sin^2(sigma/2)
      __snake_case      :    Tuple  			=(cos(a ) ** 2) * (sin(a ) ** 2)
      __snake_case      :    Dict  			=sin(sigma / 2 ) ** 2
      __snake_case      :    Tuple  			=(sigma + sin(a )) * (y_numerator / y_denominator)

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


if __name__ == "__main__":
    import doctest

    doctest.testmod()


