"""simple docstring"""






from collections import Counter
import datasets
import transformers
from transformers.convert_slow_tokenizer import SLOW_TO_FAST_CONVERTERS

from transformers.utils import logging

logging.set_verbosity_info()

lowerCAmelCase__    :    Optional[int]			=      {
    name: (getattr(transformers, name), getattr(transformers, name + 'Fast')) for name in SLOW_TO_FAST_CONVERTERS
}

lowerCAmelCase__    :    Tuple			=      datasets.load_dataset('xnli', split='test+validation')

lowerCAmelCase__    :    str			=      0
lowerCAmelCase__    :    int			=      0
lowerCAmelCase__    :    Any			=      0
lowerCAmelCase__    :    Any			=      0



def     a_		(   lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase			):
				if spm_diff == list(reversed(lowerCamelCase			)			):
								# AAA -> AA+A vs A+AA case.
								return True
				elif len(lowerCamelCase			) == len(lowerCamelCase			) and fast.decode(lowerCamelCase			) == fast.decode(lowerCamelCase			):
								# Second order OK
								# Barrich -> Barr + ich vs Bar + rich
								return True
				UpperCAmelCase__			 =				slow.encode(slow.decode(lowerCamelCase			)			)
				UpperCAmelCase__			 =				fast.encode(fast.decode(lowerCamelCase			)			)
				if spm_reencoded != spm_diff and spm_reencoded == tok_reencoded:
								# Type 3 error.
								# Snehagatha ->
								#       Sne, h, aga, th, a
								#       Sne, ha, gat, ha
								# Encoding the wrong with sp does not even recover what spm gave us
								# It fits tokenizer however...
								return True
				return False



def     a_		(   lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase			):
				UpperCAmelCase__			 =				fast.encode_plus(lowerCamelCase			)[0]
				UpperCAmelCase__			 =				enc.offsets
				UpperCAmelCase__ ,      UpperCAmelCase__			 =				offsets[idx], offsets[idx - 1]
				if curr is not None and line[curr[0] : curr[1]] == "\u200f":
								return True
				if prev is not None and line[prev[0] : prev[1]] == "\u200f":
								return True



def     a_		(   lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase			):
				# Encoding can be the same with same result AAA -> A + AA vs AA + A
				# We can check that we use at least exactly the same number of tokens.
				for i, (spm_id, tok_id) in enumerate(zip(lowerCamelCase   ,     lowerCamelCase			)			):
								if spm_id != tok_id:
												break
				UpperCAmelCase__			 =				i
				for i, (spm_id, tok_id) in enumerate(zip(reversed(lowerCamelCase			)   ,     reversed(lowerCamelCase			)			)			):
								if spm_id != tok_id:
												break
				UpperCAmelCase__			 =				len(lowerCamelCase			) - i

				UpperCAmelCase__			 =				spm_ids[first:last]
				UpperCAmelCase__			 =				tok_ids[first:last]

				if check_diff(lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase			):
								return True

				if check_LTR_mark(lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase			):
								return True

				if last - first > 5:
								# We might have twice a single problem, attempt to subdivide the disjointed tokens into smaller problems
								UpperCAmelCase__			 =				Counter(spm_ids[first:last]			)
								UpperCAmelCase__			 =				Counter(tok_ids[first:last]			)

								UpperCAmelCase__			 =				{spm_ for (spm_, si) in spms.items() if toks.get(spm_   ,     0			) == si}
								UpperCAmelCase__			 =				3
								for i in range(last - first - min_width			):
												if all(spm_ids[first + i + j] in removable_tokens for j in range(lowerCamelCase			)			):
																UpperCAmelCase__			 =				[
																    k
																    for k in range(last - first - min_width			)
																    if tok_ids[first + k : first + k + min_width] == spm_ids[first + i : first + i + min_width]
																]
																for j in possible_matches:
																				if check_diff(spm_ids[first : first + i]   ,     tok_ids[first : first + j]   ,     lowerCamelCase   ,     lowerCamelCase			) and check_details(
																				    lowerCamelCase   ,     spm_ids[first + i : last]   ,     tok_ids[first + j : last]   ,     lowerCamelCase   ,     lowerCamelCase   ,     ):
																								return True

				print(f'''Spm: {[fast.decode([spm_ids[i]]			) for i in range(lowerCamelCase   ,     lowerCamelCase			)]}'''			)
				try:
								print(f'''Tok: {[fast.decode([tok_ids[i]]			) for i in range(lowerCamelCase   ,     lowerCamelCase			)]}'''			)
				except Exception:
								pass

				UpperCAmelCase__			 =				fast.decode(spm_ids[:first]			)
				UpperCAmelCase__			 =				fast.decode(spm_ids[last:]			)
				UpperCAmelCase__			 =				fast.decode(spm_ids[first:last]			)
				print()
				print(lowerCamelCase			)
				return False



def     a_		(   lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase			):
				global perfect
				global imperfect
				global wrong
				global total

				UpperCAmelCase__			 =				slow.encode(lowerCamelCase			)
				UpperCAmelCase__			 =				fast.encode(lowerCamelCase			)

				UpperCAmelCase__			 =				False
				total += 1

				if slow_ids != fast_ids:
								if check_details(lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase			):
												UpperCAmelCase__			 =				True
												imperfect += 1
								else:
												wrong += 1
				else:
								perfect += 1

				if total % 1_0_0_0_0 == 0:
								print(f'''({perfect} / {imperfect} / {wrong} ----- {perfect + imperfect + wrong})'''			)

				if skip_assert:
								return

				assert (
				    slow_ids == fast_ids
				), f'''line {text} : \n\n{slow_ids}\n{fast_ids}\n\n{slow.tokenize(lowerCamelCase			)}\n{fast.tokenize(lowerCamelCase			)}'''



def     a_		(   lowerCamelCase   ,     lowerCamelCase			):
				global batch_total
				for i in range(len(lowerCamelCase			)			):
								# premise, all languages
								for text in dataset[i]["premise"].values():
												test_string(lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase			)

								# hypothesis, all languages
								for text in dataset[i]["hypothesis"]["translation"]:
												test_string(lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase			)


if __name__ == "__main__":
						for name, (slow_class, fast_class) in TOKENIZER_CLASSES.items():
												lowerCAmelCase__    :    Tuple			=      list(slow_class.max_model_input_sizes.keys())
												for checkpoint in checkpoint_names:
																		lowerCAmelCase__    :    Tuple			=      0
																		lowerCAmelCase__    :    Optional[int]			=      0
																		lowerCAmelCase__    :    Optional[Any]			=      0
																		lowerCAmelCase__    :    List[str]			=      0

																		print(F"""========================== Checking {name}: {checkpoint} ==========================""")
																		lowerCAmelCase__    :    Union[str, Any]			=      slow_class.from_pretrained(checkpoint, force_download=True)
																		lowerCAmelCase__    :    Tuple			=      fast_class.from_pretrained(checkpoint, force_download=True)
																		test_tokenizer(slow, fast)
																		print(F"""Accuracy {perfect * 100 / total:.2f}""")




"""simple docstring"""






import requests

try:
						from django.contrib.auth import authenticate, login
						from django.shortcuts import redirect, render
except ImportError:
						lowerCAmelCase__    :    Union[str, Any]			=      print



def     a_		(   lowerCamelCase			):
				# Enter your recaptcha secret key here
				UpperCAmelCase__			 =				'secretKey'
				UpperCAmelCase__			 =				'https://www.google.com/recaptcha/api/siteverify'

				# when method is not POST, direct user to login page
				if request.method != "POST":
								return render(lowerCamelCase   ,     'login.html'			)

				# from the frontend, get username, password, and client_key
				UpperCAmelCase__			 =				request.POST.get('username'			)
				UpperCAmelCase__			 =				request.POST.get('password'			)
				UpperCAmelCase__			 =				request.POST.get('g-recaptcha-response'			)

				# post recaptcha response to Google's recaptcha api
				UpperCAmelCase__			 =				requests.post(lowerCamelCase   ,     data={'secret': secret_key, 'response': client_key}			)
				# if the recaptcha api verified our keys
				if response.json().get('success'   ,     lowerCamelCase			):
								# authenticate the user
								UpperCAmelCase__			 =				authenticate(lowerCamelCase   ,     username=lowerCamelCase   ,     password=lowerCamelCase			)
								if user_in_database:
												login(lowerCamelCase   ,     lowerCamelCase			)
												return redirect('/your-webpage'			)
				return render(lowerCamelCase   ,     'login.html'			)



