code: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  import argparse
  import glob
  import inspect
  import os
  import re
  import unittest
  
  from get_test_info import get_test_classes
  
  from tests.test_pipeline_mixin import pipeline_test_mapping
  
  
  _lowerCamelCase							:		List[str]										=						{}
  for task, _ in pipeline_test_mapping.items():
  						_lowerCamelCase							:		List[Any]										=						{'pt': None, 'tf': None}
  
  
  # DO **NOT** add item to this set (unless the reason is approved)
  _lowerCamelCase							:		List[str]										=						{
      'tests/models/esm/test_modeling_esmfold.py',  # The pipeline test mapping is added to `test_modeling_esm.py`
  }
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if "ModelTesterMixin" in [x.__name__ for x in test_class.__bases__]:
  				return "pt"
  		elif "TFModelTesterMixin" in [x.__name__ for x in test_class.__bases__]:
  				return "tf"
  		elif "FlaxModelTesterMixin" in [x.__name__ for x in test_class.__bases__]:
  				return "flax"
  		else:
  				return None
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_		,							lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if PIPELINE_TEST_MAPPING[task].get(lowercase_		,							lowercase_						) is not None:
  				return PIPELINE_TEST_MAPPING[task][framework]
  
  		_snake_case			 = pipeline_test_mapping[task]["test"]
  		_snake_case			 = None
  
  		if framework == "pt":
  				_snake_case			 = getattr(lowercase_		,							"model_mapping"		,							lowercase_						)
  		elif framework == "tf":
  				_snake_case			 = getattr(lowercase_		,							"tf_model_mapping"		,							lowercase_						)
  
  		if mapping is not None:
  				_snake_case			 = dict(mapping.items()						)
  
  		# cache the results
  		_snake_case			 = mapping
  		return mapping
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_		,							lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = get_framework(lowercase_						)
  		if framework is None:
  				return None
  		_snake_case			 = get_mapping_for_task(lowercase_		,							lowercase_						)
  		if mapping is None:
  				return None
  
  		_snake_case			 = list({model_class.config_class for model_class in test_class.all_model_classes}						)
  		if len(lowercase_						) != 1:
  				raise ValueError("There should be exactly one configuration class from `test_class.all_model_classes`."						)
  
  		# This could be a list/tuple of model classes, but it's rare.
  		_snake_case			 = mapping.get(config_classes[0]		,							lowercase_						)
  		if isinstance(lowercase_		,							(tuple, list)						):
  				_snake_case			 = sorted(lowercase_		,							key=lambda lowercase_						: x.__name__						)
  
  		return model_class
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = [(task, get_model_for_pipeline_test(lowercase_		,							lowercase_						)) for task in pipeline_test_mapping]
  		_snake_case			 = sorted([(task, model) for task, model in mapping if model is not None]		,							key=lambda lowercase_						: x[0]						)
  
  		return dict(lowercase_						)
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = get_framework(lowercase_						)
  		if framework == "pt":
  				_snake_case			 = "torch"
  		_snake_case			 = "{}"
  
  		_snake_case			 = get_pipeline_model_mapping(lowercase_						)
  		if len(lowercase_						) == 0:
  				return ""
  
  		_snake_case			 = []
  		for task, model_classes in mapping.items():
  				if isinstance(lowercase_		,							(tuple, list)						):
  						# A list/tuple of model classes
  						_snake_case			 = "(" + ", ".join([x.__name__ for x in model_classes]						) + ")"
  				else:
  						# A single model class
  						_snake_case			 = model_classes.__name__
  				texts.append(f'''"{task}": {value}'''						)
  		_snake_case			 = "{" + ", ".join(lowercase_						) + "}"
  		_snake_case			 = f'''pipeline_model_mapping = {text} if is_{framework}_available() else {default_value}'''
  
  		return text
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = {"ModelTesterMixin", "TFModelTesterMixin", "FlaxModelTesterMixin"}
  		if not issubclass(lowercase_		,							unittest.TestCase						):
  				return False
  		return len(base_class_names.intersection([x.__name__ for x in test_class.__bases__]						)						) > 0
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = [x for x in get_test_classes(lowercase_						) if is_valid_test_class(lowercase_						)]
  
  		_snake_case			 = None
  		for test_class in test_classes:
  				# If a test class has defined `pipeline_model_mapping`, let's take it
  				if getattr(lowercase_		,							"pipeline_model_mapping"		,							lowercase_						) is not None:
  						_snake_case			 = test_class
  						break
      # Take the test class with the shortest name (just a heuristic)
  		if target_test_class is None and len(lowercase_						) > 0:
  				_snake_case			 = sorted(lowercase_		,							key=lambda lowercase_						: (len(x.__name__						), x.__name__)						)[0]
  
  		return target_test_class
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_		,							lowercase_		,							lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = start_idx
  		for idx, line in enumerate(lines[start_idx:]						):
  				_snake_case			 = len(lowercase_						) - len(line.lstrip()						)
  				if idx == 0 or indent > indent_level or (indent == indent_level and line.strip() == ")"):
  						_snake_case			 = start_idx + idx
  				elif idx > 0 and indent <= indent_level:
  						# Outside the definition block of `pipeline_model_mapping`
  						break
  
  		return end_idx
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_		,							lowercase_=False						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if getattr(lowercase_		,							"pipeline_model_mapping"		,							lowercase_						) is not None:
  				if not overwrite:
  						return "", -1
  
  		_snake_case			 = get_pipeline_model_mapping_string(lowercase_						)
  		if len(lowercase_						) == 0:
  				return "", -1
  		_snake_case			 = line_to_add + "\n"
  
  		# The code defined the class `test_class`
  		_snake_case ,					_snake_case			 = inspect.getsourcelines(lowercase_						)
  		# `inspect` gives the code for an object, including decorator(s) if any.
  		# We (only) need the exact line of the class definition.
  		for idx, line in enumerate(lowercase_						):
  				if line.lstrip().startswith("class "						):
  						_snake_case			 = class_lines[idx:]
  						class_start_line_no += idx
  						break
  		_snake_case			 = class_start_line_no + len(lowercase_						) - 1
  
  		# The index in `class_lines` that starts the definition of `all_model_classes`, `all_generative_model_classes` or
  		# `pipeline_model_mapping`. This assumes they are defined in such order, and we take the start index of the last
  		# block that appears in a `test_class`.
  		_snake_case			 = None
  		# The indent level of the line at `class_lines[start_idx]` (if defined)
  		_snake_case			 = 0
  		# To record if `pipeline_model_mapping` is found in `test_class`.
  		_snake_case			 = None
  		for idx, line in enumerate(lowercase_						):
  				if line.strip().startswith("all_model_classes = "						):
  						_snake_case			 = len(lowercase_						) - len(line.lstrip()						)
  						_snake_case			 = idx
  				elif line.strip().startswith("all_generative_model_classes = "						):
  						_snake_case			 = len(lowercase_						) - len(line.lstrip()						)
  						_snake_case			 = idx
  				elif line.strip().startswith("pipeline_model_mapping = "						):
  						_snake_case			 = len(lowercase_						) - len(line.lstrip()						)
  						_snake_case			 = idx
  						_snake_case			 = line
  						break
  
  		if start_idx is None:
  				return "", -1
  		# Find the ending index (inclusive) of the above found block.
  		_snake_case			 = find_block_ending(lowercase_		,							lowercase_		,							lowercase_						)
  
  		# Extract `is_xxx_available()` from existing blocks: some models require specific libraries like `timm` and use
  		# `is_timm_available()` instead of `is_torch_available()`.
  		# Keep leading and trailing whitespaces
  		_snake_case			 = re.compile(r"\s(is_\S+?_available\(\))\s"						)
  		for line in class_lines[start_idx : end_idx + 1]:
  				_snake_case			 = r.search(lowercase_						)
  				if backend_condition is not None:
  						# replace the leading and trailing whitespaces to the space character " ".
  						_snake_case			 = " " + backend_condition[0][1:-1] + " "
  						_snake_case			 = r.sub(lowercase_		,							lowercase_						)
  						break
  
  		if def_line is None:
  				# `pipeline_model_mapping` is not defined. The target index is set to the ending index (inclusive) of
  				# `all_model_classes` or `all_generative_model_classes`.
  				_snake_case			 = end_idx
  		else:
  				# `pipeline_model_mapping` is defined. The target index is set to be one **BEFORE** its start index.
  				_snake_case			 = start_idx - 1
  				# mark the lines of the currently existing `pipeline_model_mapping` to be removed.
  				for idx in range(lowercase_		,							end_idx + 1						):
  						# These lines are going to be removed before writing to the test file.
  						_snake_case			 = None  # noqa
  
      # Make sure the test class is a subclass of `PipelineTesterMixin`.
  		_snake_case			 = [x.__name__ for x in test_class.__bases__]
  		if "PipelineTesterMixin" not in parent_classes:
  				# Put `PipelineTesterMixin` just before `unittest.TestCase`
  				_snake_case			 = [x for x in parent_classes if x != "TestCase"] + ["PipelineTesterMixin"]
  				if "TestCase" in parent_classes:
  						# Here we **assume** the original string is always with `unittest.TestCase`.
  						_parent_classes.append("unittest.TestCase"						)
  				_snake_case			 = ", ".join(_parent_classes						)
  				for idx, line in enumerate(lowercase_						):
  						# Find the ending of the declaration of `test_class`
  						if line.strip().endswith("):"						):
  								# mark the lines of the declaration of `test_class` to be removed
  								for _idx in range(idx + 1						):
  										_snake_case			 = None  # noqa
  								break
          # Add the new, one-line, class declaration for `test_class`
  				_snake_case			 = f'''class {test_class.__name__}({parent_classes}):\n'''
  
  		# Add indentation
  		_snake_case			 = " " * indent_level + line_to_add
  		# Insert `pipeline_model_mapping` to `class_lines`.
  		# (The line at `target_idx` should be kept by definition!)
  		_snake_case			 = class_lines[: target_idx + 1] + [line_to_add] + class_lines[target_idx + 1 :]
  		# Remove the lines that are marked to be removed
  		_snake_case			 = [x for x in class_lines if x is not None]
  
  		# Move from test class to module (in order to write to the test file)
  		_snake_case			 = inspect.getsourcelines(inspect.getmodule(lowercase_						)						)[0]
  		# Be careful with the 1-off between line numbers and array indices
  		_snake_case			 = module_lines[: class_start_line_no - 1] + class_lines + module_lines[class_end_line_no:]
  		_snake_case			 = "".join(lowercase_						)
  
  		_snake_case			 = inspect.getsourcefile(lowercase_						)
  		with open(lowercase_		,							"w"		,							encoding="UTF-8"		,							newline="\n"						) as fp:
  				fp.write(lowercase_						)
  
  		return line_to_add
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_		,							lowercase_=False						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = find_test_class(lowercase_						)
  		if test_class:
  				add_pipeline_model_mapping(lowercase_		,							overwrite=lowercase_						)
  
  
  if __name__ == "__main__":
  						_lowerCamelCase							:		List[str]										=						argparse.ArgumentParser()
  						parser.add_argument(
  						    '--test_file', type=str, help='A path to the test file, starting with the repository\'s `tests` directory.'
  						)
  						parser.add_argument(
  						    '--all',
  						    action='store_true',
  						    help='If to check and modify all test files.',
  						)
  						parser.add_argument(
  						    '--overwrite',
  						    action='store_true',
  						    help='If to overwrite a test class if it has already defined `pipeline_model_mapping`.',
  						)
  						_lowerCamelCase							:		Union[str, Any]										=						parser.parse_args()
  
  						if not args.all and not args.test_file:
  												raise ValueError('Please specify either `test_file` or pass `--all` to check/modify all test files.')
  						elif args.all and args.test_file:
  												raise ValueError('Only one of `--test_file` and `--all` could be specified.')
  
  						_lowerCamelCase							:		Optional[Any]										=						[]
  						if args.test_file:
  												_lowerCamelCase							:		List[Any]										=						[args.test_file]
  						else:
  												_lowerCamelCase							:		Union[str, Any]										=						os.path.join('tests', 'models', '**', 'test_modeling_*.py')
  												for test_file in glob.glob(pattern):
  																		# `Flax` is not concerned at this moment
  																		if not test_file.startswith('test_modeling_flax_'):
  																								test_files.append(test_file)
  
  						for test_file in test_files:
  												if test_file in TEST_FILE_TO_IGNORE:
  																		print(F'''[SKIPPED] {test_file} is skipped as it is in `TEST_FILE_TO_IGNORE` in the file {__file__}.''')
  																		continue
  												add_pipeline_model_mapping_to_test_file(test_file, overwrite=args.overwrite)
  
  
  
  
  
  
style_context: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  import json
  from typing import List, Optional, Tuple
  
  from tokenizers import normalizers
  
  from ...tokenization_utils import AddedToken
  from ...tokenization_utils_fast import PreTrainedTokenizerFast
  from ...utils import logging
  from .tokenization_mpnet import MPNetTokenizer
  
  
  _lowerCamelCase							:		int										=						logging.get_logger(__name__)
  
  _lowerCamelCase							:		Any										=						{'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}
  
  _lowerCamelCase							:		Dict										=						{
      'vocab_file': {
          'microsoft/mpnet-base': 'https://huggingface.co/microsoft/mpnet-base/resolve/main/vocab.txt',
      },
      'tokenizer_file': {
          'microsoft/mpnet-base': 'https://huggingface.co/microsoft/mpnet-base/resolve/main/tokenizer.json',
      },
  }
  
  _lowerCamelCase							:		List[str]										=						{
      'microsoft/mpnet-base': 512,
  }
  
  _lowerCamelCase							:		Tuple										=						{
      'microsoft/mpnet-base': {'do_lower_case': True},
  }
  
  
  
  
  
  class   lowerCamelCase_							( UpperCAmelCase_							):
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  					lowercase__					=				VOCAB_FILES_NAMES
  					lowercase__					=				PRETRAINED_VOCAB_FILES_MAP
  					lowercase__					=				PRETRAINED_INIT_CONFIGURATION
  					lowercase__					=				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  					lowercase__					=				MPNetTokenizer
  					lowercase__					=				["""input_ids""", """attention_mask"""]
  
  
  
  
  
  
  					def __init__(					self,						__UpperCamelCase=None,						__UpperCamelCase=None,						__UpperCamelCase=True,						__UpperCamelCase="<s>",						__UpperCamelCase="</s>",						__UpperCamelCase="</s>",						__UpperCamelCase="<s>",						__UpperCamelCase="[UNK]",						__UpperCamelCase="<pad>",						__UpperCamelCase="<mask>",						__UpperCamelCase=True,						__UpperCamelCase=None,						**__UpperCamelCase,						):
  							super().__init__(
  							    __UpperCamelCase,						tokenizer_file=__UpperCamelCase,						do_lower_case=__UpperCamelCase,						bos_token=__UpperCamelCase,						eos_token=__UpperCamelCase,						sep_token=__UpperCamelCase,						cls_token=__UpperCamelCase,						unk_token=__UpperCamelCase,						pad_token=__UpperCamelCase,						mask_token=__UpperCamelCase,						tokenize_chinese_chars=__UpperCamelCase,						strip_accents=__UpperCamelCase,						**__UpperCamelCase,						)
  
  							_snake_case			 = json.loads(self.backend_tokenizer.normalizer.__getstate__()				)
  							if (
  							    pre_tok_state.get("lowercase",						__UpperCamelCase				) != do_lower_case
  							    or pre_tok_state.get("strip_accents",						__UpperCamelCase				) != strip_accents
  							):
  									_snake_case			 = getattr(__UpperCamelCase,						pre_tok_state.pop("type"				)				)
  									_snake_case			 = do_lower_case
  									_snake_case			 = strip_accents
  									_snake_case			 = pre_tok_class(**__UpperCamelCase				)
  
  							_snake_case			 = do_lower_case
  
  
  
  
  
  
  					@property
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							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        __SCREAMING_SNAKE_CASE			(					self,						__UpperCamelCase				):
  							_snake_case			 = AddedToken(__UpperCamelCase,						lstrip=__UpperCamelCase,						rstrip=__UpperCamelCase				) if isinstance(__UpperCamelCase,						__UpperCamelCase				) else value
  							_snake_case			 = value
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self,						__UpperCamelCase,						__UpperCamelCase=None				):
  							_snake_case			 = [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        __SCREAMING_SNAKE_CASE			(					self,						__UpperCamelCase,						__UpperCamelCase = None				):
  							_snake_case			 = [self.sep_token_id]
  							_snake_case			 = [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]
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self,						__UpperCamelCase,						__UpperCamelCase = None				):
  							_snake_case			 = self._tokenizer.model.save(__UpperCamelCase,						name=__UpperCamelCase				)
  							return tuple(__UpperCamelCase				)
  
  
  
  
  
  