



"""simple docstring"""
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, PLBartTokenizer, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


_lowerCAmelCase       :int	=   get_tests_dir('fixtures/test_sentencepiece.model')


if is_torch_available():
  from transformers.models.plbart.modeling_plbart import shift_tokens_right

_lowerCAmelCase       :List[Any]	=   50_003
_lowerCAmelCase       :str	=   50_002
@require_sentencepiece
@require_tokenizers
class 				_UpperCAmelCase				(					UpperCamelCase__						,unittest.TestCase ):





     '''simple docstring'''



     a__   							=PLBartTokenizer
     a__   							=None
     a__   							=False





     def 					__lowerCAmelCase      (   self						)				->   Union[str, Any]:
         super().setUp()

         # We have a SentencePiece fixture for testing
         _UpperCAmelCase				:    List[str]											=       PLBartTokenizer(A			,      language_codes='''base'''			,      keep_accents=A						)
         tokenizer.save_pretrained(self.tmpdirname						)





     def 					__lowerCAmelCase      (   self						)				->   int:
         _UpperCAmelCase				:    Optional[Any]											=       PLBartTokenizer(A			,      language_codes='''base'''			,      keep_accents=A						)

         _UpperCAmelCase				:    Optional[Any]											=       tokenizer.tokenize('''This is a test'''						)
         self.assertListEqual(A			,      ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']						)

         self.assertListEqual(
             tokenizer.convert_tokens_to_ids(A						)			,      [value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]]			,      )

         _UpperCAmelCase				:    Dict											=       tokenizer.tokenize('''I was born in 92000, and this is falsé.'''						)
         self.assertListEqual(
             A			,      [
                 SPIECE_UNDERLINE + '''I''',
                 SPIECE_UNDERLINE + '''was''',
                 SPIECE_UNDERLINE + '''b''',
                 '''or''',
                 '''n''',
                 SPIECE_UNDERLINE + '''in''',
                 SPIECE_UNDERLINE + '''''',
                 '''9''',
                 '''2''',
                 '''0''',
                 '''0''',
                 '''0''',
                 ''',''',
                 SPIECE_UNDERLINE + '''and''',
                 SPIECE_UNDERLINE + '''this''',
                 SPIECE_UNDERLINE + '''is''',
                 SPIECE_UNDERLINE + '''f''',
                 '''al''',
                 '''s''',
                 '''é''',
                 '''.''',
             ]			,      )
         _UpperCAmelCase				:    List[Any]											=       tokenizer.convert_tokens_to_ids(A						)
         self.assertListEqual(
             A			,      [
                 value + tokenizer.fairseq_offset
                 for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
             ]			,      )

         _UpperCAmelCase				:    Optional[Any]											=       tokenizer.convert_ids_to_tokens(A						)
         self.assertListEqual(
             A			,      [
                 SPIECE_UNDERLINE + '''I''',
                 SPIECE_UNDERLINE + '''was''',
                 SPIECE_UNDERLINE + '''b''',
                 '''or''',
                 '''n''',
                 SPIECE_UNDERLINE + '''in''',
                 SPIECE_UNDERLINE + '''''',
                 '''<unk>''',
                 '''2''',
                 '''0''',
                 '''0''',
                 '''0''',
                 ''',''',
                 SPIECE_UNDERLINE + '''and''',
                 SPIECE_UNDERLINE + '''this''',
                 SPIECE_UNDERLINE + '''is''',
                 SPIECE_UNDERLINE + '''f''',
                 '''al''',
                 '''s''',
                 '''<unk>''',
                 '''.''',
             ]			,      )

         _UpperCAmelCase				:    Union[str, Any]											=       tokenizer.vocab_size
         _UpperCAmelCase				:    List[Any]											=       [tokenizer.convert_ids_to_tokens(A						) for x in range(end - 4			,      A						)]

         self.assertListEqual(A			,      ['''__java__''', '''__python__''', '''__en_XX__''', '''<mask>''']						)

         _UpperCAmelCase				:    Optional[Any]											=       '''java.lang.Exception, python.lang.Exception, javascript, php, ruby, go'''
         _UpperCAmelCase				:    List[Any]											=       tokenizer(A						).input_ids
         self.assertEqual(
             tokenizer.decode(A			,      skip_special_tokens=A			,      clean_up_tokenization_spaces=A						)			,      A			,      )





     def 					__lowerCAmelCase      (   self						)				->   Tuple:
         _UpperCAmelCase				:    Union[str, Any]											=       PLBartTokenizer(A			,      language_codes='''multi'''			,      keep_accents=A						)

         _UpperCAmelCase				:    List[str]											=       tokenizer.tokenize('''This is a test'''						)
         self.assertListEqual(A			,      ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']						)

         self.assertListEqual(
             tokenizer.convert_tokens_to_ids(A						)			,      [value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]]			,      )

         _UpperCAmelCase				:    int											=       tokenizer.tokenize('''I was born in 92000, and this is falsé.'''						)
         self.assertListEqual(
             A			,      [
                 SPIECE_UNDERLINE + '''I''',
                 SPIECE_UNDERLINE + '''was''',
                 SPIECE_UNDERLINE + '''b''',
                 '''or''',
                 '''n''',
                 SPIECE_UNDERLINE + '''in''',
                 SPIECE_UNDERLINE + '''''',
                 '''9''',
                 '''2''',
                 '''0''',
                 '''0''',
                 '''0''',
                 ''',''',
                 SPIECE_UNDERLINE + '''and''',
                 SPIECE_UNDERLINE + '''this''',
                 SPIECE_UNDERLINE + '''is''',
                 SPIECE_UNDERLINE + '''f''',
                 '''al''',
                 '''s''',
                 '''é''',
                 '''.''',
             ]			,      )
         _UpperCAmelCase				:    Dict											=       tokenizer.convert_tokens_to_ids(A						)
         self.assertListEqual(
             A			,      [
                 value + tokenizer.fairseq_offset
                 for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
             ]			,      )

         _UpperCAmelCase				:    List[Any]											=       tokenizer.convert_ids_to_tokens(A						)
         self.assertListEqual(
             A			,      [
                 SPIECE_UNDERLINE + '''I''',
                 SPIECE_UNDERLINE + '''was''',
                 SPIECE_UNDERLINE + '''b''',
                 '''or''',
                 '''n''',
                 SPIECE_UNDERLINE + '''in''',
                 SPIECE_UNDERLINE + '''''',
                 '''<unk>''',
                 '''2''',
                 '''0''',
                 '''0''',
                 '''0''',
                 ''',''',
                 SPIECE_UNDERLINE + '''and''',
                 SPIECE_UNDERLINE + '''this''',
                 SPIECE_UNDERLINE + '''is''',
                 SPIECE_UNDERLINE + '''f''',
                 '''al''',
                 '''s''',
                 '''<unk>''',
                 '''.''',
             ]			,      )
         _UpperCAmelCase				:    Optional[Any]											=       tokenizer.vocab_size
         _UpperCAmelCase				:    int											=       [tokenizer.convert_ids_to_tokens(A						) for x in range(end - 7			,      A						)]

         self.assertListEqual(
             A			,      ['''__java__''', '''__python__''', '''__en_XX__''', '''__javascript__''', '''__php__''', '''__ruby__''', '''__go__''']						)
         _UpperCAmelCase				:    Union[str, Any]											=       '''java.lang.Exception, python.lang.Exception, javascript, php, ruby, go'''
         _UpperCAmelCase				:    Dict											=       tokenizer(A						).input_ids
         self.assertEqual(
             tokenizer.decode(A			,      skip_special_tokens=A			,      clean_up_tokenization_spaces=A						)			,      A			,      )



@require_torch
@require_sentencepiece
@require_tokenizers
class 				_UpperCAmelCase				(					unittest.TestCase ):





     '''simple docstring'''



     a__   							='uclanlp/plbart-python-en_XX'
     a__   							=[
         'def maximum(a,b,c):NEW_LINE_INDENTreturn max([a,b,c])',
         'def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])',
     ]
     a__   							=[
         'Returns the maximum value of a b c.',
         'Sums the values of a b c.',
     ]
     a__   							=[
         1_3_4,
         5_4_5_2,
         3_3_4_6_0,
         3_3_4_4_1,
         3_3_4_6_3,
         3_3_4_6_5,
         3_3_4_6_3,
         3_3_4_4_9,
         9_8_8,
         2_0,
         3_3_4_5_6,
         1_9,
         3_3_4_5_6,
         7_7_1,
         3_9,
         4_2_5_8,
         8_8_9,
         3_3_1_8,
         3_3_4_4_1,
         3_3_4_6_3,
         3_3_4_6_5,
         3_3_4_6_3,
         3_3_4_4_9,
         2_4_7_1,
         2,
         PYTHON_CODE,
     ]





     @classmethod
     def 					__lowerCAmelCase      (   cls						)				->   Union[str, Any]:
         _UpperCAmelCase				:    Tuple											=       PLBartTokenizer.from_pretrained(
             cls.checkpoint_name			,      language_codes='''base'''			,      src_lang='''python'''			,      tgt_lang='''en_XX'''						)
         _UpperCAmelCase				:    Any											=       1
         return cls





     def 					__lowerCAmelCase      (   self						)				->   Optional[int]:
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''__java__''']			,      5_0_0_0_1						)
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''__python__''']			,      5_0_0_0_2						)
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''__en_XX__''']			,      5_0_0_0_3						)





     def 					__lowerCAmelCase      (   self						)				->   int:
         _UpperCAmelCase				:    Any											=       self.tokenizer.batch_encode_plus(self.src_text						).input_ids[0]
         self.assertListEqual(self.expected_src_tokens			,      A						)





     def 					__lowerCAmelCase      (   self						)				->   Dict:
         self.assertIn(A			,      self.tokenizer.all_special_ids						)
         _UpperCAmelCase				:    Any											=       [EN_CODE, 9_0_3_7, 3_3_4_4_2, 5_7, 7_5_2, 1_5_3, 1_4, 5_6, 1_8, 9, 2]
         _UpperCAmelCase				:    str											=       self.tokenizer.decode(A			,      skip_special_tokens=A						)
         _UpperCAmelCase				:    List[Any]											=       self.tokenizer.decode(generated_ids[1:]			,      skip_special_tokens=A						)
         self.assertEqual(A			,      A						)
         self.assertNotIn(self.tokenizer.eos_token			,      A						)





     def 					__lowerCAmelCase      (   self						)				->   Optional[Any]:
         _UpperCAmelCase				:    Dict											=       ['''def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])''' * 2_0]
         self.assertIsInstance(src_text[0]			,      A						)
         _UpperCAmelCase				:    List[Any]											=       1_0
         _UpperCAmelCase				:    int											=       self.tokenizer(A			,      max_length=A			,      truncation=A						).input_ids[0]
         self.assertEqual(ids[-2]			,      2						)
         self.assertEqual(ids[-1]			,      A						)
         self.assertEqual(len(A						)			,      A						)





     def 					__lowerCAmelCase      (   self						)				->   Union[str, Any]:
         self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['''<mask>''', '''__java__''']						)			,      [5_0_0_0_4, 5_0_0_0_1]						)





     def 					__lowerCAmelCase      (   self						)				->   Any:
         _UpperCAmelCase				:    List[Any]											=       tempfile.mkdtemp()
         _UpperCAmelCase				:    List[str]											=       self.tokenizer.fairseq_tokens_to_ids
         self.tokenizer.save_pretrained(A						)
         _UpperCAmelCase				:    List[str]											=       PLBartTokenizer.from_pretrained(A						)
         self.assertDictEqual(new_tok.fairseq_tokens_to_ids			,      A						)





     @require_torch
     def 					__lowerCAmelCase      (   self						)				->   Any:
         _UpperCAmelCase				:    Union[str, Any]											=       self.tokenizer(self.src_text			,      text_target=self.tgt_text			,      padding=A			,      return_tensors='''pt'''						)
         _UpperCAmelCase				:    Optional[int]											=       shift_tokens_right(batch['''labels''']			,      self.tokenizer.pad_token_id						)

         # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
         self.assertEqual(batch.input_ids[1][-2:].tolist()			,      [2, PYTHON_CODE]						)
         self.assertEqual(batch.decoder_input_ids[1][0]			,      A						)
         self.assertEqual(batch.decoder_input_ids[1][-1]			,      2						)
         self.assertEqual(batch.labels[1][-2:].tolist()			,      [2, EN_CODE]						)





     @require_torch
     def 					__lowerCAmelCase      (   self						)				->   Dict:
         _UpperCAmelCase				:    Union[str, Any]											=       self.tokenizer(
             self.src_text			,      text_target=self.tgt_text			,      padding=A			,      truncation=A			,      max_length=len(self.expected_src_tokens						)			,      return_tensors='''pt'''			,      )
         _UpperCAmelCase				:    int											=       shift_tokens_right(batch['''labels''']			,      self.tokenizer.pad_token_id						)

         self.assertIsInstance(A			,      A						)

         self.assertEqual((2, 2_6)			,      batch.input_ids.shape						)
         self.assertEqual((2, 2_6)			,      batch.attention_mask.shape						)
         _UpperCAmelCase				:    Optional[Any]											=       batch.input_ids.tolist()[0]
         self.assertListEqual(self.expected_src_tokens			,      A						)
         self.assertEqual(2			,      batch.decoder_input_ids[0, -1]						)  # EOS
         # Test that special tokens are reset
         self.assertEqual(self.tokenizer.prefix_tokens			,      []						)
         self.assertEqual(self.tokenizer.suffix_tokens			,      [self.tokenizer.eos_token_id, PYTHON_CODE]						)





     def 					__lowerCAmelCase      (   self						)				->   Any:
         _UpperCAmelCase				:    Union[str, Any]											=       self.tokenizer(self.src_text			,      padding=A			,      truncation=A			,      max_length=3			,      return_tensors='''pt'''						)
         _UpperCAmelCase				:    List[Any]											=       self.tokenizer(
             text_target=self.tgt_text			,      padding=A			,      truncation=A			,      max_length=1_0			,      return_tensors='''pt'''						)
         _UpperCAmelCase				:    List[str]											=       targets['''input_ids''']
         _UpperCAmelCase				:    Dict											=       shift_tokens_right(A			,      self.tokenizer.pad_token_id						)

         self.assertEqual(batch.input_ids.shape[1]			,      3						)
         self.assertEqual(batch.decoder_input_ids.shape[1]			,      1_0						)





     @require_torch
     def 					__lowerCAmelCase      (   self						)				->   Any:
         _UpperCAmelCase				:    Dict											=       self.tokenizer._build_translation_inputs(
             '''A test'''			,      return_tensors='''pt'''			,      src_lang='''en_XX'''			,      tgt_lang='''java'''						)

         self.assertEqual(
             nested_simplify(A						)			,      {
                 # A, test, EOS, en_XX
                 '''input_ids''': [[1_5_0, 2_4_2, 2, 5_0_0_0_3]],
                 '''attention_mask''': [[1, 1, 1, 1]],
                 # java
                 '''forced_bos_token_id''': 5_0_0_0_1,
             }			,      )




'''simple docstring'''
import requests

lowercase__											=''  # <-- Put your OpenWeatherMap appid here!
lowercase__											='https://api.openweathermap.org/data/2.5/'






def      UpperCamelCase_				(      A__ = "Chicago"  ,      A__ = APPID						):
	return requests.get(URL_BASE + """weather"""  ,      params=locals()						).json()






def      UpperCamelCase_				(      A__ = "Kolkata, India"  ,      A__ = APPID						):
	return requests.get(URL_BASE + """forecast"""  ,      params=locals()						).json()






def      UpperCamelCase_				(      A__ = 55.68  ,      A__ = 12.57  ,      A__ = APPID						):
	return requests.get(URL_BASE + """onecall"""  ,      params=locals()						).json()


if __name__ == "__main__":
		from pprint import pprint

		while True:
				lowercase__											=input('Enter a location:').strip()
				if location:
						pprint(current_weather(location))
				else:
						break
