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
  
  
  UpperCamelCase_     			=       {}
  for task, _ in pipeline_test_mapping.items():
       UpperCamelCase_     			=       {"""pt""": None, """tf""": None}
  
  
  # DO **NOT** add item to this set (unless the reason is approved)
  UpperCamelCase_     			=       {
      """tests/models/esm/test_modeling_esmfold.py""",  # The pipeline test mapping is added to `test_modeling_esm.py`
  }
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Optional[Any]		)    ->						Tuple:
  
    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 	_UpperCAmelCase				(  _lowerCamelCase						:       Tuple  ,      _lowerCamelCase						:       Any		)    ->						Optional[int]:
    # Use the cached results
    if PIPELINE_TEST_MAPPING[task].get(_lowerCamelCase  ,      _lowerCamelCase		) is not None:
      return PIPELINE_TEST_MAPPING[task][framework]
  
    _lowerCAmelCase       :  Any   				=					pipeline_test_mapping[task]["""test"""]
    _lowerCAmelCase       :  Union[str, Any]   				=					None
  
    if framework == "pt":
      _lowerCAmelCase       :  List[str]   				=					getattr(_lowerCamelCase  ,      """model_mapping"""  ,      _lowerCamelCase		)
    elif framework == "tf":
      _lowerCAmelCase       :  int   				=					getattr(_lowerCamelCase  ,      """tf_model_mapping"""  ,      _lowerCamelCase		)
  
    if mapping is not None:
      _lowerCAmelCase       :  Union[str, Any]   				=					dict(mapping.items()		)
  
    # cache the results
    _lowerCAmelCase       :  Union[str, Any]   				=					mapping
    return mapping
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Tuple  ,      _lowerCamelCase						:       Optional[Any]		)    ->						int:
    _lowerCAmelCase       :  Any   				=					get_framework(_lowerCamelCase		)
    if framework is None:
      return None
    _lowerCAmelCase       :  List[str]   				=					get_mapping_for_task(_lowerCamelCase  ,      _lowerCamelCase		)
    if mapping is None:
      return None
  
    _lowerCAmelCase       :  Optional[int]   				=					list({model_class.config_class for model_class in test_class.all_model_classes}		)
    if len(_lowerCamelCase		) != 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.
    _lowerCAmelCase       :  int   				=					mapping.get(config_classes[0]  ,      _lowerCamelCase		)
    if isinstance(_lowerCamelCase  ,      (tuple, list)		):
      _lowerCAmelCase       :  int   				=					sorted(_lowerCamelCase  ,      key=lambda _lowerCamelCase		: x.__name__		)
  
    return model_class
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Dict		)    ->						Dict:
    _lowerCAmelCase       :  Optional[int]   				=					[(task, get_model_for_pipeline_test(_lowerCamelCase  ,      _lowerCamelCase		)) for task in pipeline_test_mapping]
    _lowerCAmelCase       :  List[str]   				=					sorted([(task, model) for task, model in mapping if model is not None]  ,      key=lambda _lowerCamelCase		: x[0]		)
  
    return dict(_lowerCamelCase		)
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Dict		)    ->						Union[str, Any]:
    _lowerCAmelCase       :  Optional[Any]   				=					get_framework(_lowerCamelCase		)
    if framework == "pt":
      _lowerCAmelCase       :  Tuple   				=					"""torch"""
    _lowerCAmelCase       :  List[str]   				=					"""{}"""
  
    _lowerCAmelCase       :  Optional[Any]   				=					get_pipeline_model_mapping(_lowerCamelCase		)
    if len(_lowerCamelCase		) == 0:
      return ""
  
    _lowerCAmelCase       :  List[str]   				=					[]
    for task, model_classes in mapping.items():
      if isinstance(_lowerCamelCase  ,      (tuple, list)		):
        # A list/tuple of model classes
        _lowerCAmelCase       :  Dict   				=					"""(""" + """, """.join([x.__name__ for x in model_classes]		) + """)"""
      else:
        # A single model class
        _lowerCAmelCase       :  Union[str, Any]   				=					model_classes.__name__
      texts.append(f'"{task}": {value}'		)
    _lowerCAmelCase       :  int   				=					"""{""" + """, """.join(_lowerCamelCase		) + """}"""
    _lowerCAmelCase       :  List[str]   				=					f'pipeline_model_mapping = {text} if is_{framework}_available() else {default_value}'
  
    return text
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Tuple		)    ->						List[str]:
    _lowerCAmelCase       :  List[str]   				=					{"""ModelTesterMixin""", """TFModelTesterMixin""", """FlaxModelTesterMixin"""}
    if not issubclass(_lowerCamelCase  ,      unittest.TestCase		):
      return False
    return len(base_class_names.intersection([x.__name__ for x in test_class.__bases__]		)		) > 0
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       List[Any]		)    ->						Optional[int]:
    _lowerCAmelCase       :  Dict   				=					[x for x in get_test_classes(_lowerCamelCase		) if is_valid_test_class(_lowerCamelCase		)]
  
    _lowerCAmelCase       :  Optional[int]   				=					None
    for test_class in test_classes:
      # If a test class has defined `pipeline_model_mapping`, let's take it
      if getattr(_lowerCamelCase  ,      """pipeline_model_mapping"""  ,      _lowerCamelCase		) is not None:
        _lowerCAmelCase       :  Optional[int]   				=					test_class
        break
      # Take the test class with the shortest name (just a heuristic)
    if target_test_class is None and len(_lowerCamelCase		) > 0:
      _lowerCAmelCase       :  List[Any]   				=					sorted(_lowerCamelCase  ,      key=lambda _lowerCamelCase		: (len(x.__name__		), x.__name__)		)[0]
  
    return target_test_class
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       int  ,      _lowerCamelCase						:       Dict  ,      _lowerCamelCase						:       str		)    ->						int:
    _lowerCAmelCase       :  Dict   				=					start_idx
    for idx, line in enumerate(lines[start_idx:]		):
      _lowerCAmelCase       :  Optional[int]   				=					len(_lowerCamelCase		) - len(line.lstrip()		)
      if idx == 0 or indent > indent_level or (indent == indent_level and line.strip() == ")"):
        _lowerCAmelCase       :  Optional[int]   				=					start_idx + idx
      elif idx > 0 and indent <= indent_level:
        # Outside the definition block of `pipeline_model_mapping`
        break
  
    return end_idx
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Tuple  ,      _lowerCamelCase						:       int=False		)    ->						Optional[int]:
    if getattr(_lowerCamelCase  ,      """pipeline_model_mapping"""  ,      _lowerCamelCase		) is not None:
      if not overwrite:
        return "", -1
  
    _lowerCAmelCase       :  str   				=					get_pipeline_model_mapping_string(_lowerCamelCase		)
    if len(_lowerCamelCase		) == 0:
      return "", -1
    _lowerCAmelCase       :  List[Any]   				=					line_to_add + """\n"""
  
    # The code defined the class `test_class`
    _lowerCAmelCase				,					_lowerCAmelCase       :  Dict   				=					inspect.getsourcelines(_lowerCamelCase		)
    # `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(_lowerCamelCase		):
      if line.lstrip().startswith("""class """		):
        _lowerCAmelCase       :  int   				=					class_lines[idx:]
        class_start_line_no += idx
        break
    _lowerCAmelCase       :  Tuple   				=					class_start_line_no + len(_lowerCamelCase		) - 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`.
    _lowerCAmelCase       :  List[Any]   				=					None
    # The indent level of the line at `class_lines[start_idx]` (if defined)
    _lowerCAmelCase       :  int   				=					0
    # To record if `pipeline_model_mapping` is found in `test_class`.
    _lowerCAmelCase       :  List[Any]   				=					None
    for idx, line in enumerate(_lowerCamelCase		):
      if line.strip().startswith("""all_model_classes = """		):
        _lowerCAmelCase       :  Optional[Any]   				=					len(_lowerCamelCase		) - len(line.lstrip()		)
        _lowerCAmelCase       :  Optional[Any]   				=					idx
      elif line.strip().startswith("""all_generative_model_classes = """		):
        _lowerCAmelCase       :  str   				=					len(_lowerCamelCase		) - len(line.lstrip()		)
        _lowerCAmelCase       :  Union[str, Any]   				=					idx
      elif line.strip().startswith("""pipeline_model_mapping = """		):
        _lowerCAmelCase       :  List[Any]   				=					len(_lowerCamelCase		) - len(line.lstrip()		)
        _lowerCAmelCase       :  Optional[Any]   				=					idx
        _lowerCAmelCase       :  Any   				=					line
        break
  
    if start_idx is None:
      return "", -1
    # Find the ending index (inclusive) of the above found block.
    _lowerCAmelCase       :  Any   				=					find_block_ending(_lowerCamelCase  ,      _lowerCamelCase  ,      _lowerCamelCase		)
  
    # 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
    _lowerCAmelCase       :  Union[str, Any]   				=					re.compile(R"""\s(is_\S+?_available\(\))\s"""		)
    for line in class_lines[start_idx : end_idx + 1]:
      _lowerCAmelCase       :  Optional[Any]   				=					r.search(_lowerCamelCase		)
      if backend_condition is not None:
        # replace the leading and trailing whitespaces to the space character " ".
        _lowerCAmelCase       :  Optional[int]   				=					""" """ + backend_condition[0][1:-1] + """ """
        _lowerCAmelCase       :  List[str]   				=					r.sub(_lowerCamelCase  ,      _lowerCamelCase		)
        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`.
      _lowerCAmelCase       :  List[str]   				=					end_idx
    else:
      # `pipeline_model_mapping` is defined. The target index is set to be one **BEFORE** its start index.
      _lowerCAmelCase       :  List[str]   				=					start_idx - 1
      # mark the lines of the currently existing `pipeline_model_mapping` to be removed.
      for idx in range(_lowerCamelCase  ,      end_idx + 1		):
        # These lines are going to be removed before writing to the test file.
        _lowerCAmelCase       :  List[Any]   				=					None  # noqa
  
      # Make sure the test class is a subclass of `PipelineTesterMixin`.
    _lowerCAmelCase       :  str   				=					[x.__name__ for x in test_class.__bases__]
    if "PipelineTesterMixin" not in parent_classes:
      # Put `PipelineTesterMixin` just before `unittest.TestCase`
      _lowerCAmelCase       :  List[str]   				=					[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"""		)
      _lowerCAmelCase       :  Any   				=					""", """.join(_parent_classes		)
      for idx, line in enumerate(_lowerCamelCase		):
        # 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		):
            _lowerCAmelCase       :  str   				=					None  # noqa
          break
          # Add the new, one-line, class declaration for `test_class`
      _lowerCAmelCase       :  Union[str, Any]   				=					f'class {test_class.__name__}({parent_classes}):\n'
  
    # Add indentation
    _lowerCAmelCase       :  Tuple   				=					""" """ * indent_level + line_to_add
    # Insert `pipeline_model_mapping` to `class_lines`.
    # (The line at `target_idx` should be kept by definition!)
    _lowerCAmelCase       :  Dict   				=					class_lines[: target_idx + 1] + [line_to_add] + class_lines[target_idx + 1 :]
    # Remove the lines that are marked to be removed
    _lowerCAmelCase       :  Dict   				=					[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)
    _lowerCAmelCase       :  Union[str, Any]   				=					inspect.getsourcelines(inspect.getmodule(_lowerCamelCase		)		)[0]
    # Be careful with the 1-off between line numbers and array indices
    _lowerCAmelCase       :  str   				=					module_lines[: class_start_line_no - 1] + class_lines + module_lines[class_end_line_no:]
    _lowerCAmelCase       :  List[Any]   				=					"""""".join(_lowerCamelCase		)
  
    _lowerCAmelCase       :  Dict   				=					inspect.getsourcefile(_lowerCamelCase		)
    with open(_lowerCamelCase  ,      """w"""  ,      encoding="""UTF-8"""  ,      newline="""\n"""		) as fp:
      fp.write(_lowerCamelCase		)
  
    return line_to_add
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Union[str, Any]  ,      _lowerCamelCase						:       Tuple=False		)    ->						Any:
    _lowerCAmelCase       :  str   				=					find_test_class(_lowerCamelCase		)
    if test_class:
      add_pipeline_model_mapping(_lowerCamelCase  ,      overwrite=_lowerCamelCase		)
  
  
  if __name__ == "__main__":
       UpperCamelCase_     			=       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`.""",
       )
       UpperCamelCase_     			=       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.""")
  
       UpperCamelCase_     			=       []
       if args.test_file:
            UpperCamelCase_     			=       [args.test_file]
       else:
            UpperCamelCase_     			=       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'''
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_flax_available,
      is_tf_available,
      is_torch_available,
  )
  
  
  UpperCamelCase_     			=       {
      """configuration_gptsan_japanese""": ["""GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPTSanJapaneseConfig"""],
      """tokenization_gptsan_japanese""": ["""GPTSanJapaneseTokenizer"""],
  }
  
  try:
       if not is_torch_available():
            raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
       pass
  else:
       UpperCamelCase_     			=       [
           """GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST""",
           """GPTSanJapaneseForConditionalGeneration""",
           """GPTSanJapaneseModel""",
           """GPTSanJapanesePreTrainedModel""",
       ]
       UpperCamelCase_     			=       [
           """GPTSanJapaneseTokenizer""",
       ]
  
  
  if TYPE_CHECKING:
       from .configuration_gptsan_japanese import GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTSanJapaneseConfig
       from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer
  
       try:
            if not is_torch_available():
                 raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
            pass
       else:
            from .modeling_gptsan_japanese import (
                GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
                GPTSanJapaneseForConditionalGeneration,
                GPTSanJapaneseModel,
                GPTSanJapanesePreTrainedModel,
            )
            from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer
  
  
  else:
       import sys
  
       UpperCamelCase_     			=       _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
  
  
  