


'''simple docstring'''



import json
from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers, processors

from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_bart import BartTokenizer


__lowercase	:						List[Any]       =	logging.get_logger(__name__)


__lowercase	:						Union[str, Any]       =	{'vocab_file': 'vocab.json', 'merges_file': 'merges.txt', 'tokenizer_file': 'tokenizer.json'}

# See all BART models at https://huggingface.co/models?filter=bart
__lowercase	:						Optional[Any]       =	{
    'vocab_file': {
        'facebook/bart-base': 'https://huggingface.co/facebook/bart-base/resolve/main/vocab.json',
        'facebook/bart-large': 'https://huggingface.co/facebook/bart-large/resolve/main/vocab.json',
        'facebook/bart-large-mnli': 'https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json',
        'facebook/bart-large-cnn': 'https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json',
        'facebook/bart-large-xsum': 'https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json',
        'yjernite/bart_eli5': 'https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json',
    },
    'merges_file': {
        'facebook/bart-base': 'https://huggingface.co/facebook/bart-base/resolve/main/merges.txt',
        'facebook/bart-large': 'https://huggingface.co/facebook/bart-large/resolve/main/merges.txt',
        'facebook/bart-large-mnli': 'https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt',
        'facebook/bart-large-cnn': 'https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt',
        'facebook/bart-large-xsum': 'https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt',
        'yjernite/bart_eli5': 'https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt',
    },
    'tokenizer_file': {
        'facebook/bart-base': 'https://huggingface.co/facebook/bart-base/resolve/main/tokenizer.json',
        'facebook/bart-large': 'https://huggingface.co/facebook/bart-large/resolve/main/tokenizer.json',
        'facebook/bart-large-mnli': 'https://huggingface.co/facebook/bart-large-mnli/resolve/main/tokenizer.json',
        'facebook/bart-large-cnn': 'https://huggingface.co/facebook/bart-large-cnn/resolve/main/tokenizer.json',
        'facebook/bart-large-xsum': 'https://huggingface.co/facebook/bart-large-xsum/resolve/main/tokenizer.json',
        'yjernite/bart_eli5': 'https://huggingface.co/yjernite/bart_eli5/resolve/main/tokenizer.json',
    },
}

__lowercase	:						Dict       =	{
    'facebook/bart-base': 10_24,
    'facebook/bart-large': 10_24,
    'facebook/bart-large-mnli': 10_24,
    'facebook/bart-large-cnn': 10_24,
    'facebook/bart-large-xsum': 10_24,
    'yjernite/bart_eli5': 10_24,
}





class 							__UpperCamelCase				(		lowerCAmelCase_					):
	A_				=    VOCAB_FILES_NAMES
	A_				=    PRETRAINED_VOCAB_FILES_MAP
	A_				=    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	A_				=    ["input_ids", "attention_mask"]
	A_				=    BartTokenizer




	def __init__(   self						,				__a=None						,				__a=None						,				__a=None						,				__a="replace"						,				__a="<s>"						,				__a="</s>"						,				__a="</s>"						,				__a="<s>"						,				__a="<unk>"						,				__a="<pad>"						,				__a="<mask>"						,				__a=False						,				__a=True						,				**__a						,				):

						'''simple docstring'''





						super().__init__(
						    __a						,				__a						,				tokenizer_file=__a						,				errors=__a						,				bos_token=__a						,				eos_token=__a						,				sep_token=__a						,				cls_token=__a						,				unk_token=__a						,				pad_token=__a						,				mask_token=__a						,				add_prefix_space=__a						,				trim_offsets=__a						,				**__a						,				)

						__a			:       Optional[Any]					    =  json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()							)
						if pre_tok_state.get('add_prefix_space'						,				__a							) != add_prefix_space:
											__a			:       Tuple					    =  getattr(__a						,				pre_tok_state.pop('type'							)							)
											__a			:       List[str]					    =  add_prefix_space
											__a			:       int					    =  pre_tok_class(**__a							)

						__a			:       Union[str, Any]					    =  add_prefix_space

						# the pre_tokenizer is already updated in the GPT2TokenizerFast `__init__`
						__a			:       Union[str, Any]					    =  'post_processor'
						__a			:       str					    =  getattr(self.backend_tokenizer						,				__a						,				__a							)
						if tokenizer_component_instance:
											__a			:       Dict					    =  json.loads(tokenizer_component_instance.__getstate__()							)

											# The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
											if "sep" in state:
																__a			:       Optional[Any]					    =  tuple(state['sep']							)
											if "cls" in state:
																__a			:       Any					    =  tuple(state['cls']							)

											__a			:       str					    =  False

											if state.get('add_prefix_space'						,				__a							) != add_prefix_space:
																__a			:       Dict					    =  add_prefix_space
																__a			:       Tuple					    =  True

											if state.get('trim_offsets'						,				__a							) != trim_offsets:
																__a			:       Optional[Any]					    =  trim_offsets
																__a			:       Dict					    =  True

											if changes_to_apply:
																__a			:       Tuple					    =  getattr(__a						,				state.pop('type'							)							)
																__a			:       Optional[Any]					    =  component_class(**__a							)
																setattr(self.backend_tokenizer						,				__a						,				__a							)




	@property
	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						if self._mask_token is None:
											if self.verbose:
																logger.error('Using mask_token, but it is not set yet.'							)
											return None
						return str(self._mask_token							)




	@mask_token.setter
	def       __UpperCAmelCase							(   self						,				__a							):

						'''simple docstring'''





						__a			:       Dict					    =  AddedToken(__a						,				lstrip=__a						,				rstrip=__a							) if isinstance(__a						,				__a							) else value
						__a			:       Union[str, Any]					    =  value




	def       __UpperCAmelCase							(   self						,				*__a						,				**__a							):

						'''simple docstring'''





						__a			:       Optional[int]					    =  kwargs.get('is_split_into_words'						,				__a							)

						if is_split_into_words and not self.add_prefix_space:
											raise ValueError(
											    f"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
											    'to use it with pretokenized inputs.'							)

						return super()._batch_encode_plus(*__a						,				**__a							)




	def       __UpperCAmelCase							(   self						,				*__a						,				**__a							):

						'''simple docstring'''





						__a			:       List[Any]					    =  kwargs.get('is_split_into_words'						,				__a							)

						if is_split_into_words and not self.add_prefix_space:
											raise ValueError(
											    f"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
											    'to use it with pretokenized inputs.'							)

						return super()._encode_plus(*__a						,				**__a							)




	def       __UpperCAmelCase							(   self						,				__a						,				__a = None							):

						'''simple docstring'''





						__a			:       str					    =  self._tokenizer.model.save(__a						,				name=__a							)
						return tuple(__a							)




	def       __UpperCAmelCase							(   self						,				__a						,				__a=None							):

						'''simple docstring'''





						__a			:       Optional[int]					    =  [self.bos_token_id] + token_ids_a + [self.eos_token_id]
						if token_ids_a is None:
											return output

						return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]





	def       __UpperCAmelCase							(   self						,				__a						,				__a = None							):

						'''simple docstring'''





						__a			:       str					    =  [self.sep_token_id]
						__a			:       str					    =  [self.cls_token_id]

						if token_ids_a is None:
											return len(cls + token_ids_a + sep							) * [0]
						return len(cls + token_ids_a + sep + sep + token_ids_a + sep							) * [0]







'''simple docstring'''



import requests

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






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   str = "Chicago"						,      _SCREAMING_SNAKE_CASE      :   str = APPID   ):
					return requests.get(URL_BASE + 'weather'						,      params=locals()   ).json()






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   str = "Kolkata, India"						,      _SCREAMING_SNAKE_CASE      :   str = APPID   ):
					return requests.get(URL_BASE + 'forecast'						,      params=locals()   ).json()






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   float = 5_5.6_8						,      _SCREAMING_SNAKE_CASE      :   float = 1_2.5_7						,      _SCREAMING_SNAKE_CASE      :   str = APPID   ):
					return requests.get(URL_BASE + 'onecall'						,      params=locals()   ).json()


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

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



