




import argparse
import json
import math
import os
import time
import traceback
import zipfile
from collections import Counter

import requests


def 						lowerCamelCase__    (		_A     ,	_A=None							):







	'''simple docstring'''





	snake_case_		    =     None
	if token is not None:
		snake_case_		    =     {"Accept": "application/vnd.github+json", "Authorization": f"Bearer {token}"}

	snake_case_		    =     f"https://api.github.com/repos/huggingface/transformers/actions/runs/{workflow_run_id}/jobs?per_page=100"
	snake_case_		    =     requests.get(_A     ,	headers=_A							).json()
	snake_case_		    =     {}

	try:
		job_links.update({job["name"]: job["html_url"] for job in result["jobs"]}							)
		snake_case_		    =     math.ceil((result["total_count"] - 100) / 100							)

		for i in range(_A							):
			snake_case_		    =     requests.get(url + f"&page={i + 2}"     ,	headers=_A							).json()
			job_links.update({job["name"]: job["html_url"] for job in result["jobs"]}							)

		return job_links
	except Exception:
		print(f"Unknown error, could not fetch links:\n{traceback.format_exc()}"							)

	return {}


def 						lowerCamelCase__    (		_A     ,	_A=None							):







	'''simple docstring'''





	snake_case_		    =     None
	if token is not None:
		snake_case_		    =     {"Accept": "application/vnd.github+json", "Authorization": f"Bearer {token}"}

	snake_case_		    =     f"https://api.github.com/repos/huggingface/transformers/actions/runs/{worflow_run_id}/artifacts?per_page=100"
	snake_case_		    =     requests.get(_A     ,	headers=_A							).json()
	snake_case_		    =     {}

	try:
		artifacts.update({artifact["name"]: artifact["archive_download_url"] for artifact in result["artifacts"]}							)
		snake_case_		    =     math.ceil((result["total_count"] - 100) / 100							)

		for i in range(_A							):
			snake_case_		    =     requests.get(url + f"&page={i + 2}"     ,	headers=_A							).json()
			artifacts.update({artifact["name"]: artifact["archive_download_url"] for artifact in result["artifacts"]}							)

		return artifacts
	except Exception:
		print(f"Unknown error, could not fetch links:\n{traceback.format_exc()}"							)

	return {}


def 						lowerCamelCase__    (		_A     ,	_A     ,	_A     ,	_A							):







	'''simple docstring'''





	snake_case_		    =     None
	if token is not None:
		snake_case_		    =     {"Accept": "application/vnd.github+json", "Authorization": f"Bearer {token}"}

	snake_case_		    =     requests.get(_A     ,	headers=_A     ,	allow_redirects=_A							)
	snake_case_		    =     result.headers["Location"]
	snake_case_		    =     requests.get(_A     ,	allow_redirects=_A							)
	snake_case_		    =     os.path.join(_A     ,	f"{artifact_name}.zip"							)
	with open(_A     ,	"wb"							) as fp:
		fp.write(response.content							)


def 						lowerCamelCase__    (		_A     ,	_A=None							):







	'''simple docstring'''





	snake_case_		    =     []
	snake_case_		    =     []
	snake_case_		    =     None

	with zipfile.ZipFile(_A							) as z:
		for filename in z.namelist():
			if not os.path.isdir(_A							):
				# read the file
				if filename in ["failures_line.txt", "summary_short.txt", "job_name.txt"]:
					with z.open(_A							) as f:
						for line in f:
							snake_case_		    =     line.decode("UTF-8"							).strip()
							if filename == "failures_line.txt":
								try:
									# `error_line` is the place where `error` occurs
									snake_case_		    =     line[: line.index(": "							)]
									snake_case_		    =     line[line.index(": "							) + len(": "							) :]
									errors.append([error_line, error]							)
								except Exception:
									# skip un-related lines
									pass
							elif filename == "summary_short.txt" and line.startswith("FAILED "							):
								# `test` is the test method that failed
								snake_case_		    =     line[len("FAILED "							) :]
								failed_tests.append(_A							)
							elif filename == "job_name.txt":
								snake_case_		    =     line

	if len(_A							) != len(_A							):
		raise ValueError(
		    f"`errors` and `failed_tests` should have the same number of elements. Got {len(_A							)} for `errors` "
		    f"and {len(_A							)} for `failed_tests` instead. The test reports in {artifact_zip_path} have some"
		    " problem."							)

	snake_case_		    =     None
	if job_name and job_links:
		snake_case_		    =     job_links.get(_A     ,	_A							)

	# A list with elements of the form (line of error, error, failed test)
	snake_case_		    =     [x + [y] + [job_link] for x, y in zip(_A     ,	_A							)]

	return result


def 						lowerCamelCase__    (		_A     ,	_A=None							):







	'''simple docstring'''





	snake_case_		    =     []

	snake_case_		    =     [os.path.join(_A     ,	_A							) for p in os.listdir(_A							) if p.endswith(".zip"							)]
	for p in paths:
		errors.extend(get_errors_from_single_artifact(_A     ,	job_links=_A							)							)

	return errors


def 						lowerCamelCase__    (		_A     ,	_A=None							):







	'''simple docstring'''





	snake_case_		    =     Counter()
	counter.update([x[1] for x in logs]							)
	snake_case_		    =     counter.most_common()
	snake_case_		    =     {}
	for error, count in counts:
		if error_filter is None or error not in error_filter:
			snake_case_		    =     {"count": count, "failed_tests": [(x[2], x[0]) for x in logs if x[1] == error]}

	snake_case_		    =     dict(sorted(r.items()     ,	key=lambda _A							: item[1]["count"]     ,	reverse=_A							)							)
	return r


def 						lowerCamelCase__    (		_A							):







	'''simple docstring'''





	snake_case_		    =     test.split("::"							)[0]
	if test.startswith("tests/models/"							):
		snake_case_		    =     test.split("/"							)[2]
	else:
		snake_case_		    =     None

	return test


def 						lowerCamelCase__    (		_A     ,	_A=None							):







	'''simple docstring'''





	snake_case_		    =     [(x[0], x[1], get_model(x[2]							)) for x in logs]
	snake_case_		    =     [x for x in logs if x[2] is not None]
	snake_case_		    =     {x[2] for x in logs}

	snake_case_		    =     {}
	for test in tests:
		snake_case_		    =     Counter()
		# count by errors in `test`
		counter.update([x[1] for x in logs if x[2] == test]							)
		snake_case_		    =     counter.most_common()
		snake_case_		    =     {error: count for error, count in counts if (error_filter is None or error not in error_filter)}
		snake_case_		    =     sum(error_counts.values()							)
		if n_errors > 0:
			snake_case_		    =     {"count": n_errors, "errors": error_counts}

	snake_case_		    =     dict(sorted(r.items()     ,	key=lambda _A							: item[1]["count"]     ,	reverse=_A							)							)
	return r


def 						lowerCamelCase__    (		_A							):







	'''simple docstring'''





	snake_case_		    =     "| no. | error | status |"
	snake_case_		    =     "|-:|:-|:-|"
	snake_case_		    =     [header, sep]
	for error in reduced_by_error:
		snake_case_		    =     reduced_by_error[error]["count"]
		snake_case_		    =     f"| {count} | {error[:100]} |  |"
		lines.append(_A							)

	return "\n".join(_A							)


def 						lowerCamelCase__    (		_A							):







	'''simple docstring'''





	snake_case_		    =     "| model | no. of errors | major error | count |"
	snake_case_		    =     "|-:|-:|-:|-:|"
	snake_case_		    =     [header, sep]
	for model in reduced_by_model:
		snake_case_		    =     reduced_by_model[model]["count"]
		snake_case_    ,      snake_case_		    =     list(reduced_by_model[model]["errors"].items()							)[0]
		snake_case_		    =     f"| {model} | {count} | {error[:60]} | {_count} |"
		lines.append(_A							)

	return "\n".join(_A							)


if __name__ == "__main__":
		lowercase__				:     int 		=						argparse.ArgumentParser()
		# Required parameters
		parser.add_argument("--workflow_run_id", type=str, required=True, help="A GitHub Actions workflow run id.")
		parser.add_argument(
		    "--output_dir",
		    type=str,
		    required=True,
		    help="Where to store the downloaded artifacts and other result files.",
		)
		parser.add_argument("--token", default=None, type=str, help="A token that has actions:read permission.")
		lowercase__				:     int 		=						parser.parse_args()

		os.makedirs(args.output_dir, exist_ok=True)

		lowercase__				:     Optional[Any] 		=						get_job_links(args.workflow_run_id, token=args.token)
		lowercase__				:     List[Any] 		=						{}
		# To deal with `workflow_call` event, where a job name is the combination of the job names in the caller and callee.
		# For example, `PyTorch 1.11 / Model tests (models/albert, single-gpu)`.
		if _job_links:
				for k, v in _job_links.items():
						# This is how GitHub actions combine job names.
						if " / " in k:
								lowercase__				:     Tuple 		=						k.find(" / ")
								lowercase__				:     Union[str, Any] 		=						k[index + len(" / ") :]
						lowercase__				:     Union[str, Any] 		=						v
		with open(os.path.join(args.output_dir, "job_links.json"), "w", encoding="UTF-8") as fp:
				json.dump(job_links, fp, ensure_ascii=False, indent=4)

		lowercase__				:     Any 		=						get_artifacts_links(args.workflow_run_id, token=args.token)
		with open(os.path.join(args.output_dir, "artifacts.json"), "w", encoding="UTF-8") as fp:
				json.dump(artifacts, fp, ensure_ascii=False, indent=4)

		for idx, (name, url) in enumerate(artifacts.items()):
				download_artifact(name, url, args.output_dir, args.token)
				# Be gentle to GitHub
				time.sleep(1)

		lowercase__				:     List[Any] 		=						get_all_errors(args.output_dir, job_links=job_links)

		# `e[1]` is the error
		lowercase__				:     str 		=						Counter()
		counter.update([e[1] for e in errors])

		# print the top 30 most common test errors
		lowercase__				:     Union[str, Any] 		=						counter.most_common(30)
		for item in most_common:
				print(item)

		with open(os.path.join(args.output_dir, "errors.json"), "w", encoding="UTF-8") as fp:
				json.dump(errors, fp, ensure_ascii=False, indent=4)

		lowercase__				:     int 		=						reduce_by_error(errors)
		lowercase__				:     List[str] 		=						reduce_by_model(errors)

		lowercase__				:     Tuple 		=						make_github_table(reduced_by_error)
		lowercase__				:     Optional[int] 		=						make_github_table_per_model(reduced_by_model)

		with open(os.path.join(args.output_dir, "reduced_by_error.txt"), "w", encoding="UTF-8") as fp:
				fp.write(sa)
		with open(os.path.join(args.output_dir, "reduced_by_model.txt"), "w", encoding="UTF-8") as fp:
				fp.write(sa)






import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / "utils"))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
		from test_module.custom_tokenization_fast import CustomTokenizerFast
class 		UpperCAmelCase   (				unittest.TestCase			):







						'''simple docstring'''





						def        snake_case__						(						self							:     Any						):






							"""simple docstring"""






							snake_case_		    =     0






						@slow
						def        snake_case__						(						self							:     Dict						):






							"""simple docstring"""






							for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
								snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase						)
								self.assertIsNotNone(__lowercase						)
								self.assertIsInstance(__lowercase       ,	(BertTokenizer, BertTokenizerFast)						)
								self.assertGreater(len(__lowercase						)       ,	0						)

							for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
								snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase						)
								self.assertIsNotNone(__lowercase						)
								self.assertIsInstance(__lowercase       ,	(GPTaTokenizer, GPTaTokenizerFast)						)
								self.assertGreater(len(__lowercase						)       ,	0						)






						def        snake_case__						(						self							:     int						):






							"""simple docstring"""






							snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase						)
							self.assertIsInstance(__lowercase       ,	(BertTokenizer, BertTokenizerFast)						)
							self.assertEqual(tokenizer.vocab_size       ,	12						)






						def        snake_case__						(						self							:     int						):






							"""simple docstring"""






							snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase						)
							self.assertIsInstance(__lowercase       ,	(RobertaTokenizer, RobertaTokenizerFast)						)
							self.assertEqual(tokenizer.vocab_size       ,	20						)






						def        snake_case__						(						self							:     Dict						):






							"""simple docstring"""






							snake_case_		    =     AutoConfig.from_pretrained(__lowercase						)
							self.assertIsInstance(__lowercase       ,	__lowercase						)
							# Check that tokenizer_type ≠ model_type
							snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase       ,	config=__lowercase						)
							self.assertIsInstance(__lowercase       ,	(BertTokenizer, BertTokenizerFast)						)
							self.assertEqual(tokenizer.vocab_size       ,	12						)






						def        snake_case__						(						self							:     str						):






							"""simple docstring"""






							with tempfile.TemporaryDirectory() as tmp_dir:
								shutil.copy("./tests/fixtures/vocab.txt"       ,	os.path.join(__lowercase       ,	"vocab.txt"						)						)

								snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase       ,	tokenizer_type="bert"       ,	use_fast=__lowercase						)
								self.assertIsInstance(__lowercase       ,	__lowercase						)

							with tempfile.TemporaryDirectory() as tmp_dir:
								shutil.copy("./tests/fixtures/vocab.json"       ,	os.path.join(__lowercase       ,	"vocab.json"						)						)
								shutil.copy("./tests/fixtures/merges.txt"       ,	os.path.join(__lowercase       ,	"merges.txt"						)						)

								snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase       ,	tokenizer_type="gpt2"       ,	use_fast=__lowercase						)
								self.assertIsInstance(__lowercase       ,	__lowercase						)






						@require_tokenizers
						def        snake_case__						(						self							:     Tuple						):






							"""simple docstring"""






							with tempfile.TemporaryDirectory() as tmp_dir:
								shutil.copy("./tests/fixtures/vocab.txt"       ,	os.path.join(__lowercase       ,	"vocab.txt"						)						)

								snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase       ,	tokenizer_type="bert"						)
								self.assertIsInstance(__lowercase       ,	__lowercase						)

							with tempfile.TemporaryDirectory() as tmp_dir:
								shutil.copy("./tests/fixtures/vocab.json"       ,	os.path.join(__lowercase       ,	"vocab.json"						)						)
								shutil.copy("./tests/fixtures/merges.txt"       ,	os.path.join(__lowercase       ,	"merges.txt"						)						)

								snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase       ,	tokenizer_type="gpt2"						)
								self.assertIsInstance(__lowercase       ,	__lowercase						)






						def        snake_case__						(						self							:     List[Any]						):






							"""simple docstring"""






							with pytest.raises(__lowercase						):
								AutoTokenizer.from_pretrained("./"       ,	tokenizer_type="xxx"						)






						@require_tokenizers
						def        snake_case__						(						self							:     Union[str, Any]						):






							"""simple docstring"""






							for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
								snake_case_		    =     tokenizer_class.from_pretrained("wietsedv/bert-base-dutch-cased"						)
								self.assertIsInstance(__lowercase       ,	(BertTokenizer, BertTokenizerFast)						)

								if isinstance(__lowercase       ,	__lowercase						):
									self.assertEqual(tokenizer.basic_tokenizer.do_lower_case       ,	__lowercase						)
								else:
									self.assertEqual(tokenizer.do_lower_case       ,	__lowercase						)

								self.assertEqual(tokenizer.model_max_length       ,	5_12						)






						@require_tokenizers
						def        snake_case__						(						self							:     Any						):






							"""simple docstring"""






							for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
								with self.assertRaisesRegex(
								    __lowercase       ,	"julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier"       ,	):
									snake_case_		    =     tokenizer_class.from_pretrained("julien-c/herlolip-not-exists"						)






						def        snake_case__						(						self							:     Union[str, Any]						):






							"""simple docstring"""






							snake_case_		    =     TOKENIZER_MAPPING.values()
							snake_case_		    =     []

							for slow_tok, fast_tok in tokenizers:
								if slow_tok is not None:
									tokenizer_names.append(slow_tok.__name__						)

								if fast_tok is not None:
									tokenizer_names.append(fast_tok.__name__						)

							for tokenizer_name in tokenizer_names:
								# must find the right class
								tokenizer_class_from_name(__lowercase						)






						@require_tokenizers
						def        snake_case__						(						self							:     Tuple						):






							"""simple docstring"""






							self.assertIsInstance(AutoTokenizer.from_pretrained("bert-base-cased"       ,	use_fast=__lowercase						)       ,	__lowercase						)
							self.assertIsInstance(AutoTokenizer.from_pretrained("bert-base-cased"						)       ,	__lowercase						)






						@require_tokenizers
						def        snake_case__						(						self							:     Union[str, Any]						):






							"""simple docstring"""






							snake_case_		    =     AutoTokenizer.from_pretrained("distilbert-base-uncased"       ,	do_lower_case=__lowercase						)
							snake_case_		    =     "Hello, world. How are you?"
							snake_case_		    =     tokenizer.tokenize(__lowercase						)
							self.assertEqual("[UNK]"       ,	tokens[0]						)

							snake_case_		    =     AutoTokenizer.from_pretrained("microsoft/mpnet-base"       ,	do_lower_case=__lowercase						)
							snake_case_		    =     tokenizer.tokenize(__lowercase						)
							self.assertEqual("[UNK]"       ,	tokens[0]						)






						@require_tokenizers
						def        snake_case__						(						self							:     str						):






							"""simple docstring"""






							snake_case_		    =     AutoTokenizer.from_pretrained("robot-test/dummy-tokenizer-fast-with-model-config"						)
							self.assertEqual(type(__lowercase						)       ,	__lowercase						)
							self.assertEqual(tokenizer.model_max_length       ,	5_12						)
							self.assertEqual(tokenizer.vocab_size       ,	3_00_00						)
							self.assertEqual(tokenizer.unk_token       ,	"[UNK]"						)
							self.assertEqual(tokenizer.padding_side       ,	"right"						)
							self.assertEqual(tokenizer.truncation_side       ,	"right"						)






						def        snake_case__						(						self							:     str						):






							"""simple docstring"""






							snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase						)
							self.assertIsInstance(__lowercase       ,	(BertTokenizer, BertTokenizerFast)						)
							with tempfile.TemporaryDirectory() as tmp_dir:
								tokenizer.save_pretrained(__lowercase						)
								snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase						)

							self.assertIsInstance(__lowercase       ,	tokenizer.__class__						)
							self.assertEqual(tokenizera.vocab_size       ,	12						)






						def        snake_case__						(						self							:     Tuple						):






							"""simple docstring"""






							snake_case_		    =     AutoTokenizer.from_pretrained("ctrl"						)
							# There is no fast CTRL so this always gives us a slow tokenizer.
							self.assertIsInstance(__lowercase       ,	__lowercase						)






						def        snake_case__						(						self							:     Any						):






							"""simple docstring"""






							snake_case_		    =     get_tokenizer_config("bert-base-cased"						)
							snake_case_		    =     config.pop("_commit_hash"       ,	__lowercase						)
							# If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
							self.assertEqual(__lowercase       ,	{"do_lower_case": False}						)

							# This model does not have a tokenizer_config so we get back an empty dict.
							snake_case_		    =     get_tokenizer_config(__lowercase						)
							self.assertDictEqual(__lowercase       ,	{}						)

							# A tokenizer saved with `save_pretrained` always creates a tokenizer config.
							snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase						)
							with tempfile.TemporaryDirectory() as tmp_dir:
								tokenizer.save_pretrained(__lowercase						)
								snake_case_		    =     get_tokenizer_config(__lowercase						)

							# Check the class of the tokenizer was properly saved (note that it always saves the slow class).
							self.assertEqual(config["tokenizer_class"]       ,	"BertTokenizer"						)






						def        snake_case__						(						self							:     int						):






							"""simple docstring"""






							try:
								AutoConfig.register("custom"       ,	__lowercase						)

								AutoTokenizer.register(__lowercase       ,	slow_tokenizer_class=__lowercase						)
								# Trying to register something existing in the Transformers library will raise an error
								with self.assertRaises(__lowercase						):
									AutoTokenizer.register(__lowercase       ,	slow_tokenizer_class=__lowercase						)

								snake_case_		    =     CustomTokenizer.from_pretrained(__lowercase						)
								with tempfile.TemporaryDirectory() as tmp_dir:
									tokenizer.save_pretrained(__lowercase						)

									snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase						)
									self.assertIsInstance(__lowercase       ,	__lowercase						)

							finally:
								if "custom" in CONFIG_MAPPING._extra_content:
									del CONFIG_MAPPING._extra_content["custom"]
								if CustomConfig in TOKENIZER_MAPPING._extra_content:
									del TOKENIZER_MAPPING._extra_content[CustomConfig]






						@require_tokenizers
						def        snake_case__						(						self							:     List[Any]						):






							"""simple docstring"""






							try:
								AutoConfig.register("custom"       ,	__lowercase						)

								# Can register in two steps
								AutoTokenizer.register(__lowercase       ,	slow_tokenizer_class=__lowercase						)
								self.assertEqual(TOKENIZER_MAPPING[CustomConfig]       ,	(CustomTokenizer, None)						)
								AutoTokenizer.register(__lowercase       ,	fast_tokenizer_class=__lowercase						)
								self.assertEqual(TOKENIZER_MAPPING[CustomConfig]       ,	(CustomTokenizer, CustomTokenizerFast)						)

								del TOKENIZER_MAPPING._extra_content[CustomConfig]
								# Can register in one step
								AutoTokenizer.register(
								    __lowercase       ,	slow_tokenizer_class=__lowercase       ,	fast_tokenizer_class=__lowercase						)
								self.assertEqual(TOKENIZER_MAPPING[CustomConfig]       ,	(CustomTokenizer, CustomTokenizerFast)						)

								# Trying to register something existing in the Transformers library will raise an error
								with self.assertRaises(__lowercase						):
									AutoTokenizer.register(__lowercase       ,	fast_tokenizer_class=__lowercase						)

								# We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
								# and that model does not have a tokenizer.json
								with tempfile.TemporaryDirectory() as tmp_dir:
									snake_case_		    =     BertTokenizerFast.from_pretrained(__lowercase						)
									bert_tokenizer.save_pretrained(__lowercase						)
									snake_case_		    =     CustomTokenizerFast.from_pretrained(__lowercase						)

								with tempfile.TemporaryDirectory() as tmp_dir:
									tokenizer.save_pretrained(__lowercase						)

									snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase						)
									self.assertIsInstance(__lowercase       ,	__lowercase						)

									snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase       ,	use_fast=__lowercase						)
									self.assertIsInstance(__lowercase       ,	__lowercase						)

							finally:
								if "custom" in CONFIG_MAPPING._extra_content:
									del CONFIG_MAPPING._extra_content["custom"]
								if CustomConfig in TOKENIZER_MAPPING._extra_content:
									del TOKENIZER_MAPPING._extra_content[CustomConfig]






						def        snake_case__						(						self							:     str						):






							"""simple docstring"""






							with self.assertRaises(__lowercase						):
								snake_case_		    =     AutoTokenizer.from_pretrained("hf-internal-testing/test_dynamic_tokenizer"						)
							# If remote code is disabled, we can't load this config.
							with self.assertRaises(__lowercase						):
								snake_case_		    =     AutoTokenizer.from_pretrained(
								    "hf-internal-testing/test_dynamic_tokenizer"       ,	trust_remote_code=__lowercase						)

							snake_case_		    =     AutoTokenizer.from_pretrained("hf-internal-testing/test_dynamic_tokenizer"       ,	trust_remote_code=__lowercase						)
							self.assertTrue(tokenizer.special_attribute_present						)
							# Test tokenizer can be reloaded.
							with tempfile.TemporaryDirectory() as tmp_dir:
								tokenizer.save_pretrained(__lowercase						)
								snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase       ,	trust_remote_code=__lowercase						)
							self.assertTrue(reloaded_tokenizer.special_attribute_present						)

							if is_tokenizers_available():
								self.assertEqual(tokenizer.__class__.__name__       ,	"NewTokenizerFast"						)
								self.assertEqual(reloaded_tokenizer.__class__.__name__       ,	"NewTokenizerFast"						)

								# Test we can also load the slow version
								snake_case_		    =     AutoTokenizer.from_pretrained(
								    "hf-internal-testing/test_dynamic_tokenizer"       ,	trust_remote_code=__lowercase       ,	use_fast=__lowercase						)
								self.assertTrue(tokenizer.special_attribute_present						)
								self.assertEqual(tokenizer.__class__.__name__       ,	"NewTokenizer"						)
								# Test tokenizer can be reloaded.
								with tempfile.TemporaryDirectory() as tmp_dir:
									tokenizer.save_pretrained(__lowercase						)
									snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase       ,	trust_remote_code=__lowercase       ,	use_fast=__lowercase						)
								self.assertEqual(reloaded_tokenizer.__class__.__name__       ,	"NewTokenizer"						)
								self.assertTrue(reloaded_tokenizer.special_attribute_present						)
							else:
								self.assertEqual(tokenizer.__class__.__name__       ,	"NewTokenizer"						)
								self.assertEqual(reloaded_tokenizer.__class__.__name__       ,	"NewTokenizer"						)






						@require_tokenizers
						def        snake_case__						(						self							:     Any						):






							"""simple docstring"""






							class 		UpperCAmelCase   (				UpperCAmelCase__			):







													'''simple docstring'''





													lowerCAmelCase_     		=   False







							class 		UpperCAmelCase   (				UpperCAmelCase__			):







													'''simple docstring'''





													lowerCAmelCase_     		=   NewTokenizer
													lowerCAmelCase_     		=   False

							try:
								AutoConfig.register("custom"       ,	__lowercase						)
								AutoTokenizer.register(__lowercase       ,	slow_tokenizer_class=__lowercase						)
								AutoTokenizer.register(__lowercase       ,	fast_tokenizer_class=__lowercase						)
								# If remote code is not set, the default is to use local
								snake_case_		    =     AutoTokenizer.from_pretrained("hf-internal-testing/test_dynamic_tokenizer"						)
								self.assertEqual(tokenizer.__class__.__name__       ,	"NewTokenizerFast"						)
								self.assertFalse(tokenizer.special_attribute_present						)
								snake_case_		    =     AutoTokenizer.from_pretrained("hf-internal-testing/test_dynamic_tokenizer"       ,	use_fast=__lowercase						)
								self.assertEqual(tokenizer.__class__.__name__       ,	"NewTokenizer"						)
								self.assertFalse(tokenizer.special_attribute_present						)

								# If remote code is disabled, we load the local one.
								snake_case_		    =     AutoTokenizer.from_pretrained(
								    "hf-internal-testing/test_dynamic_tokenizer"       ,	trust_remote_code=__lowercase						)
								self.assertEqual(tokenizer.__class__.__name__       ,	"NewTokenizerFast"						)
								self.assertFalse(tokenizer.special_attribute_present						)
								snake_case_		    =     AutoTokenizer.from_pretrained(
								    "hf-internal-testing/test_dynamic_tokenizer"       ,	trust_remote_code=__lowercase       ,	use_fast=__lowercase						)
								self.assertEqual(tokenizer.__class__.__name__       ,	"NewTokenizer"						)
								self.assertFalse(tokenizer.special_attribute_present						)

								# If remote is enabled, we load from the Hub
								snake_case_		    =     AutoTokenizer.from_pretrained(
								    "hf-internal-testing/test_dynamic_tokenizer"       ,	trust_remote_code=__lowercase						)
								self.assertEqual(tokenizer.__class__.__name__       ,	"NewTokenizerFast"						)
								self.assertTrue(tokenizer.special_attribute_present						)
								snake_case_		    =     AutoTokenizer.from_pretrained(
								    "hf-internal-testing/test_dynamic_tokenizer"       ,	trust_remote_code=__lowercase       ,	use_fast=__lowercase						)
								self.assertEqual(tokenizer.__class__.__name__       ,	"NewTokenizer"						)
								self.assertTrue(tokenizer.special_attribute_present						)

							finally:
								if "custom" in CONFIG_MAPPING._extra_content:
									del CONFIG_MAPPING._extra_content["custom"]
								if CustomConfig in TOKENIZER_MAPPING._extra_content:
									del TOKENIZER_MAPPING._extra_content[CustomConfig]






						def        snake_case__						(						self							:     List[Any]						):






							"""simple docstring"""






							snake_case_		    =     AutoTokenizer.from_pretrained(
							    "hf-internal-testing/test_dynamic_tokenizer_legacy"       ,	trust_remote_code=__lowercase						)
							self.assertTrue(tokenizer.special_attribute_present						)
							if is_tokenizers_available():
								self.assertEqual(tokenizer.__class__.__name__       ,	"NewTokenizerFast"						)

								# Test we can also load the slow version
								snake_case_		    =     AutoTokenizer.from_pretrained(
								    "hf-internal-testing/test_dynamic_tokenizer_legacy"       ,	trust_remote_code=__lowercase       ,	use_fast=__lowercase						)
								self.assertTrue(tokenizer.special_attribute_present						)
								self.assertEqual(tokenizer.__class__.__name__       ,	"NewTokenizer"						)
							else:
								self.assertEqual(tokenizer.__class__.__name__       ,	"NewTokenizer"						)






						def        snake_case__						(						self							:     List[Any]						):






							"""simple docstring"""






							with self.assertRaisesRegex(
							    __lowercase       ,	"bert-base is not a local folder and is not a valid model identifier"						):
								snake_case_		    =     AutoTokenizer.from_pretrained("bert-base"						)






						def        snake_case__						(						self							:     Union[str, Any]						):






							"""simple docstring"""






							with self.assertRaisesRegex(
							    __lowercase       ,	r"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"						):
								snake_case_		    =     AutoTokenizer.from_pretrained(__lowercase       ,	revision="aaaaaa"						)






						def        snake_case__						(						self							:     Any						):






							"""simple docstring"""






							snake_case_		    =     AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-bert"						)
							with RequestCounter() as counter:
								snake_case_		    =     AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-bert"						)
								self.assertEqual(counter.get_request_count       ,	0						)
								self.assertEqual(counter.head_request_count       ,	1						)
								self.assertEqual(counter.other_request_count       ,	0						)
