


import unittest

from transformers import GPTSwaTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


_UpperCAmelCase			:  Union[str, Any]     =get_tests_dir("""fixtures/test_sentencepiece_with_bytefallback.model""")







@require_sentencepiece
@require_tokenizers
class 				snake_case__(							_snake_case,						unittest.TestCase							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__      :  Any					=							GPTSwaTokenizer
						SCREAMING_SNAKE_CASE__      :  List[str]					=							False
						SCREAMING_SNAKE_CASE__      :  Optional[Any]					=							True
						SCREAMING_SNAKE_CASE__      :  List[str]					=							False




						def 						lowercase_ (				self							)					->    List[str]:
										super().setUp()

										# We have a SentencePiece fixture for testing
										lowerCAmelCase_ :      Tuple    				=				GPTSwaTokenizer(__lowercase   ,						eos_token='''<unk>'''   ,						bos_token='''<unk>'''   ,						pad_token='''<unk>'''							)

										tokenizer.save_pretrained(self.tmpdirname							)




						def 						lowercase_ (				self   ,						__lowercase							)					->    Optional[Any]:
										lowerCAmelCase_ :      str    				=				'''This is a test'''
										lowerCAmelCase_ :      Any    				=				'''This is a test'''
										return input_text, output_text




						def 						lowercase_ (				self							)					->    str:
										lowerCAmelCase_ :      Dict    				=				'''<s>'''
										lowerCAmelCase_ :      Union[str, Any]    				=				1

										self.assertEqual(self.get_tokenizer()._convert_token_to_id(__lowercase							)   ,						__lowercase							)
										self.assertEqual(self.get_tokenizer()._convert_id_to_token(__lowercase							)   ,						__lowercase							)




						def 						lowercase_ (				self							)					->    int:
										lowerCAmelCase_ :      Tuple    				=				list(self.get_tokenizer().get_vocab().keys()							)

										self.assertEqual(vocab_keys[0]   ,						'''<unk>'''							)
										self.assertEqual(vocab_keys[1]   ,						'''<s>'''							)
										self.assertEqual(vocab_keys[-1]   ,						'''j'''							)
										self.assertEqual(len(__lowercase							)   ,						2_0_0_0							)




						def 						lowercase_ (				self							)					->    str:
										self.assertEqual(self.get_tokenizer().vocab_size   ,						2_0_0_0							)




						def 						lowercase_ (				self							)					->    Optional[Any]:
										lowerCAmelCase_ :      Any    				=				GPTSwaTokenizer(__lowercase							)

										lowerCAmelCase_ :      Dict    				=				tokenizer.tokenize('''This is a test'''							)
										self.assertListEqual(__lowercase   ,						['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']							)

										self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowercase							)   ,						[4_6_5, 2_8_7, 2_6_5, 6_3_1, 8_4_2]							)

										lowerCAmelCase_ :      str    				=				tokenizer.tokenize('''I was born in 92000, and this is falsé.'''							)
										# fmt: off
										self.assertListEqual(
										    __lowercase   ,						['''▁I''', '''▁was''', '''▁bor''', '''n''', '''▁in''', '''▁''', '''<0x39>''', '''2''', '''0''', '''0''', '''0''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁f''', '''al''', '''s''', '''<0xC3>''', '''<0xA9>''', '''.''']   ,						)
										# fmt: on

										lowerCAmelCase_ :      Optional[int]    				=				tokenizer.convert_tokens_to_ids(__lowercase							)
										self.assertListEqual(
										    __lowercase   ,						[2_6_2, 2_7_2, 1_5_2_5, 2_8_6, 2_7_1, 2_6_8, 6_0, 9_1_6, 6_3_3, 6_3_3, 6_3_3, 2_5_9, 2_6_6, 3_0_1, 2_8_7, 3_8_4, 3_6_7, 2_6_3, 1_9_8, 1_7_2, 2_6_0]   ,						)

										lowerCAmelCase_ :      Optional[int]    				=				tokenizer.convert_ids_to_tokens(__lowercase							)
										# fmt: off
										self.assertListEqual(
										    __lowercase   ,						['''▁I''', '''▁was''', '''▁bor''', '''n''', '''▁in''', '''▁''', '''<0x39>''', '''2''', '''0''', '''0''', '''0''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁f''', '''al''', '''s''', '''<0xC3>''', '''<0xA9>''', '''.''']							)
										# fmt: on




						def 						lowercase_ (				self							)					->    Optional[Any]:
										lowerCAmelCase_ :      Optional[int]    				=				GPTSwaTokenizer(__lowercase							)
										lowerCAmelCase_ :      str    				=				['''This is a test''', '''I was born in 92000, and this is falsé.''']
										lowerCAmelCase_ :      int    				=				[
										    [4_6_5, 2_8_7, 2_6_5, 6_3_1, 8_4_2],
										    [2_6_2, 2_7_2, 1_5_2_5, 2_8_6, 2_7_1, 2_6_8, 6_0, 9_1_6, 6_3_3, 6_3_3, 6_3_3, 2_5_9, 2_6_6, 3_0_1, 2_8_7, 3_8_4, 3_6_7, 2_6_3, 1_9_8, 1_7_2, 2_6_0],
										]

										# Test that encode_fast returns the same as tokenize + convert_tokens_to_ids
										for text, expected_ids in zip(__lowercase   ,						__lowercase							):
														self.assertListEqual(tokenizer.encode_fast(__lowercase							)   ,						__lowercase							)

										# Test that decode_fast returns the input text
										for text, token_ids in zip(__lowercase   ,						__lowercase							):
														self.assertEqual(tokenizer.decode_fast(__lowercase							)   ,						__lowercase							)




						@slow
						def 						lowercase_ (				self							)					->    Dict:
										lowerCAmelCase_ :      str    				=				[
										    '''<|python|>def fibonacci(n)\n    if n < 0:\n        print(\'Incorrect input\')''',
										    '''Hey there, how are you doing this fine day?''',
										    '''This is a text with a trailing spaces followed by a dot     .''',
										    '''Häj sväjs lillebrör! =)''',
										    '''Det är inget fel på Mr. Cool''',
										]

										# fmt: off
										lowerCAmelCase_ :      Optional[int]    				=				{'''input_ids''': [[6_3_4_2_3, 5, 6_8_1_1, 1_4_9_5_4, 2_8_2, 8_1_6, 3_8_2_1, 6_3_4_6_6, 6_3_4_2_5, 6_3_4_6_2, 1_8, 6_3_9_7_8, 6_7_8, 3_0_1, 1_3_2_0, 6_3_4_2_3, 6_3_4_5_5, 6_3_4_5_8, 1_8, 6_3_9_8_2, 4_2_4_6, 3_9_4_0, 1_9_0_1, 4_7_7_8_9, 5_5_4_7, 1_8_9_9_4], [1_9_6_3_0, 1_1_0_0, 6_3_4_4_6, 1_3_4_2, 6_3_3, 5_4_4, 4_4_8_8, 5_9_3, 5_1_0_2, 2_4_1_6, 6_3_4_9_5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1_6_5_2, 4_2_8, 2_6_8, 1_9_3_6, 5_1_5, 2_6_8, 5_8_5_9_3, 2_2_4_1_3, 9_1_0_6, 5_4_6, 2_6_8, 3_3_2_1_3, 6_3_9_7_9, 6_9_8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5_5_1_3_0, 6_3_4_5_0, 9_2_4, 6_3_4_4_9, 2_2_4_9, 4_0_6_2, 1_5_5_8, 3_1_8, 6_3_5_0_4, 2_1_4_9_8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5_0_9, 3_7_7, 2_8_2_7, 2_5_5_9, 3_3_2, 6_5_7_5, 6_3_4_4_3, 2_6_8_0_1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], '''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]], '''attention_mask''': [[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, 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, 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], [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]]}
										# fmt: on
										self.tokenizer_integration_test_util(
										    expected_encoding=__lowercase   ,						model_name='''AI-Sweden/gpt-sw3-126m'''   ,						sequences=__lowercase   ,						)



import math
from enum import Enum
from typing import Optional, Union

from torch.optim import Optimizer
from torch.optim.lr_scheduler import LambdaLR

from .utils import logging


_UpperCAmelCase			:  Tuple     =logging.get_logger(__name__)







class 				snake_case__(							UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__      :  List[str]					=							"""linear"""
						SCREAMING_SNAKE_CASE__      :  Union[str, Any]					=							"""cosine"""
						SCREAMING_SNAKE_CASE__      :  Dict					=							"""cosine_with_restarts"""
						SCREAMING_SNAKE_CASE__      :  List[str]					=							"""polynomial"""
						SCREAMING_SNAKE_CASE__      :  Dict					=							"""constant"""
						SCREAMING_SNAKE_CASE__      :  List[str]					=							"""constant_with_warmup"""
						SCREAMING_SNAKE_CASE__      :  str					=							"""piecewise_constant"""






def 			lowerCAmelCase (		lowerCAmelCase_ ,   lowerCAmelCase_ = -1 )-> Tuple:
				return LambdaLR(lowerCAmelCase_ ,   lambda lowerCAmelCase_ : 1 ,   last_epoch=lowerCAmelCase_ )



def 			lowerCAmelCase (		lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ = -1 )-> List[Any]:

				def lr_lambda(lowerCAmelCase_ ):
								if current_step < num_warmup_steps:
												return float(lowerCAmelCase_ ) / float(max(1.0 ,   lowerCAmelCase_ ) )
								return 1.0

				return LambdaLR(lowerCAmelCase_ ,   lowerCAmelCase_ ,   last_epoch=lowerCAmelCase_ )



def 			lowerCAmelCase (		lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ = -1 )-> int:
				lowerCAmelCase_ :      Optional[int]    				=				{}
				lowerCAmelCase_ :      Union[str, Any]    				=				step_rules.split(''',''' )
				for rule_str in rule_list[:-1]:
								lowerCAmelCase_				,  lowerCAmelCase_ :      str    				=				rule_str.split(''':''' )
								lowerCAmelCase_ :      int    				=				int(lowerCAmelCase_ )
								lowerCAmelCase_ :      str    				=				float(lowerCAmelCase_ )
								lowerCAmelCase_ :      List[Any]    				=				value
				lowerCAmelCase_ :      int    				=				float(rule_list[-1] )

				def create_rules_function(lowerCAmelCase_ ,   lowerCAmelCase_ ):
								def rule_func(lowerCAmelCase_ ) -> float:
												lowerCAmelCase_ :      Tuple    				=				sorted(rules_dict.keys() )
												for i, sorted_step in enumerate(lowerCAmelCase_ ):
																if steps < sorted_step:
																				return rules_dict[sorted_steps[i]]
												return last_lr_multiple

								return rule_func

				lowerCAmelCase_ :      Tuple    				=				create_rules_function(lowerCAmelCase_ ,   lowerCAmelCase_ )

				return LambdaLR(lowerCAmelCase_ ,   lowerCAmelCase_ ,   last_epoch=lowerCAmelCase_ )



def 			lowerCAmelCase (		lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_=-1 )-> Optional[int]:

				def lr_lambda(lowerCAmelCase_ ):
								if current_step < num_warmup_steps:
												return float(lowerCAmelCase_ ) / float(max(1 ,   lowerCAmelCase_ ) )
								return max(
								    0.0 ,   float(num_training_steps - current_step ) / float(max(1 ,   num_training_steps - num_warmup_steps ) ) )

				return LambdaLR(lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ )



def 			lowerCAmelCase (		lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ = 0.5 ,   lowerCAmelCase_ = -1 )-> List[Any]:

				def lr_lambda(lowerCAmelCase_ ):
								if current_step < num_warmup_steps:
												return float(lowerCAmelCase_ ) / float(max(1 ,   lowerCAmelCase_ ) )
								lowerCAmelCase_ :      Tuple    				=				float(current_step - num_warmup_steps ) / float(max(1 ,   num_training_steps - num_warmup_steps ) )
								return max(0.0 ,   0.5 * (1.0 + math.cos(math.pi * float(lowerCAmelCase_ ) * 2.0 * progress )) )

				return LambdaLR(lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ )



def 			lowerCAmelCase (		lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ = 1 ,   lowerCAmelCase_ = -1 )-> Dict:

				def lr_lambda(lowerCAmelCase_ ):
								if current_step < num_warmup_steps:
												return float(lowerCAmelCase_ ) / float(max(1 ,   lowerCAmelCase_ ) )
								lowerCAmelCase_ :      List[Any]    				=				float(current_step - num_warmup_steps ) / float(max(1 ,   num_training_steps - num_warmup_steps ) )
								if progress >= 1.0:
												return 0.0
								return max(0.0 ,   0.5 * (1.0 + math.cos(math.pi * ((float(lowerCAmelCase_ ) * progress) % 1.0) )) )

				return LambdaLR(lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ )



def 			lowerCAmelCase (		lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_=1e-7 ,   lowerCAmelCase_=1.0 ,   lowerCAmelCase_=-1 )-> Any:
				lowerCAmelCase_ :      Dict    				=				optimizer.defaults['''lr''']
				if not (lr_init > lr_end):
								raise ValueError(f"""lr_end ({lr_end}) must be be smaller than initial lr ({lr_init})""" )

				def lr_lambda(lowerCAmelCase_ ):
								if current_step < num_warmup_steps:
												return float(lowerCAmelCase_ ) / float(max(1 ,   lowerCAmelCase_ ) )
								elif current_step > num_training_steps:
												return lr_end / lr_init  # as LambdaLR multiplies by lr_init
								else:
												lowerCAmelCase_ :      List[Any]    				=				lr_init - lr_end
												lowerCAmelCase_ :      Optional[Any]    				=				num_training_steps - num_warmup_steps
												lowerCAmelCase_ :      Any    				=				1 - (current_step - num_warmup_steps) / decay_steps
												lowerCAmelCase_ :      List[Any]    				=				lr_range * pct_remaining**power + lr_end
												return decay / lr_init  # as LambdaLR multiplies by lr_init

				return LambdaLR(lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ )


_UpperCAmelCase			:  Union[str, Any]     ={
    SchedulerType.LINEAR: get_linear_schedule_with_warmup,
    SchedulerType.COSINE: get_cosine_schedule_with_warmup,
    SchedulerType.COSINE_WITH_RESTARTS: get_cosine_with_hard_restarts_schedule_with_warmup,
    SchedulerType.POLYNOMIAL: get_polynomial_decay_schedule_with_warmup,
    SchedulerType.CONSTANT: get_constant_schedule,
    SchedulerType.CONSTANT_WITH_WARMUP: get_constant_schedule_with_warmup,
    SchedulerType.PIECEWISE_CONSTANT: get_piecewise_constant_schedule,
}




def 			lowerCAmelCase (		lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ = None ,   lowerCAmelCase_ = None ,   lowerCAmelCase_ = None ,   lowerCAmelCase_ = 1 ,   lowerCAmelCase_ = 1.0 ,   lowerCAmelCase_ = -1 ,   )-> Optional[int]:
				lowerCAmelCase_ :      Union[str, Any]    				=				SchedulerType(lowerCAmelCase_ )
				lowerCAmelCase_ :      Optional[int]    				=				TYPE_TO_SCHEDULER_FUNCTION[name]
				if name == SchedulerType.CONSTANT:
								return schedule_func(lowerCAmelCase_ ,   last_epoch=lowerCAmelCase_ )

				if name == SchedulerType.PIECEWISE_CONSTANT:
								return schedule_func(lowerCAmelCase_ ,   step_rules=lowerCAmelCase_ ,   last_epoch=lowerCAmelCase_ )

				# All other schedulers require `num_warmup_steps`
				if num_warmup_steps is None:
								raise ValueError(f"""{name} requires `num_warmup_steps`, please provide that argument.""" )

				if name == SchedulerType.CONSTANT_WITH_WARMUP:
								return schedule_func(lowerCAmelCase_ ,   num_warmup_steps=lowerCAmelCase_ ,   last_epoch=lowerCAmelCase_ )

				# All other schedulers require `num_training_steps`
				if num_training_steps is None:
								raise ValueError(f"""{name} requires `num_training_steps`, please provide that argument.""" )

				if name == SchedulerType.COSINE_WITH_RESTARTS:
								return schedule_func(
								    lowerCAmelCase_ ,   num_warmup_steps=lowerCAmelCase_ ,   num_training_steps=lowerCAmelCase_ ,   num_cycles=lowerCAmelCase_ ,   last_epoch=lowerCAmelCase_ ,   )

				if name == SchedulerType.POLYNOMIAL:
								return schedule_func(
								    lowerCAmelCase_ ,   num_warmup_steps=lowerCAmelCase_ ,   num_training_steps=lowerCAmelCase_ ,   power=lowerCAmelCase_ ,   last_epoch=lowerCAmelCase_ ,   )

				return schedule_func(
				    lowerCAmelCase_ ,   num_warmup_steps=lowerCAmelCase_ ,   num_training_steps=lowerCAmelCase_ ,   last_epoch=lowerCAmelCase_ )